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) => {
14 // This should generally only be used to print panic messages
15 console.log("FD_WRITE to " + fd + " in " + iovec_array_len + " chunks.");
16 const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
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(String.fromCharCode(...bytes_view));
23 "fd_close": (_fd: number) => {
24 // This is not generally called, but may be referenced in debug builds
25 console.log("wasi_snapshot_preview1:fd_close");
26 return 58; // Not Supported
28 "fd_seek": (_fd: number, _offset: bigint, _whence: number, _new_offset: number) => {
29 // This is not generally called, but may be referenced in debug builds
30 console.log("wasi_snapshot_preview1:fd_seek");
31 return 58; // Not Supported
33 "random_get": (buf_ptr: number, buf_len: number) => {
34 const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len);
38 "environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
39 // This is called before fd_write to format + print panic messages
40 console.log("wasi_snapshot_preview1:environ_sizes_get");
41 const out_count_view = new Uint32Array(wasm.memory.buffer, environ_var_count_ptr, 1);
42 out_count_view[0] = 0;
43 const out_len_view = new Uint32Array(wasm.memory.buffer, environ_len_ptr, 1);
47 "environ_get": (environ_ptr: number, environ_buf_ptr: number) => {
48 // This is called before fd_write to format + print panic messages
49 console.log("wasi_snapshot_preview1:environ_get");
50 return 58; // Note supported - we said there were 0 environment entries!
53 console.log("wasi_snapshot_preview1:proc_exit");
58 let isWasmInitialized: boolean = false;
60 async function finishInitializeWasm(wasmInstance: WebAssembly.Instance) {
61 if (typeof crypto === "undefined") {
62 var crypto_import = (await import('crypto')).webcrypto;
63 getRandomValues = crypto_import.getRandomValues.bind(crypto_import);
65 getRandomValues = crypto.getRandomValues.bind(crypto);
68 wasm = wasmInstance.exports;
69 if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) {
70 throw new Error("Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint");
73 if (decodeString(wasm.TS_get_lib_version_string()) !== version.get_ldk_java_bindings_version())
74 throw new Error("Compiled LDK library and LDK class files do not match");
75 // Fetching the LDK versions from C also checks that the header and binaries match
76 const c_bindings_ver: number = wasm.TS_get_ldk_c_bindings_version();
77 const ldk_ver: number = wasm.TS_get_ldk_version();
78 if (c_bindings_ver == 0)
79 throw new Error("LDK version did not match the header we built against");
81 throw new Error("LDK C bindings version did not match the header we built against");
82 const c_bindings_version: string = decodeString(c_bindings_ver)
83 const ldk_version: string = decodeString(ldk_ver);
84 console.log("Loaded LDK-Java Bindings with LDK " + ldk_version + " and LDK-C-Bindings " + c_bindings_version);
86 isWasmInitialized = true;
90 export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
91 imports.env["js_invoke_function_u"] = js_invoke;
92 imports.env["js_invoke_function_b"] = js_invoke;
93 const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
94 await finishInitializeWasm(wasmInstance);
98 export async function initializeWasmFetch(uri: string) {
99 const stream = fetch(uri);
100 imports.env["js_invoke_function_u"] = js_invoke;
101 imports.env["js_invoke_function_b"] = js_invoke;
102 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
103 await finishInitializeWasm(wasmInstance);
108 export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
109 const arr = new Uint8Array(inputArray.length);
110 for (var i = 0; i < inputArray.length; i++) {
111 arr[i] = inputArray[i].getVal();
117 export function WitnessVersionArrToBytes(inputArray: Array<WitnessVersion>): Uint8Array {
118 const arr = new Uint8Array(inputArray.length);
119 for (var i = 0; i < inputArray.length; i++) {
120 arr[i] = inputArray[i].getVal();
128 export function encodeUint8Array (inputArray: Uint8Array): number {
129 const cArrayPointer = wasm.TS_malloc(inputArray.length + 4);
130 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
131 arrayLengthView[0] = inputArray.length;
132 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
133 arrayMemoryView.set(inputArray);
134 return cArrayPointer;
137 export function encodeUint32Array (inputArray: Uint32Array|Array<number>): number {
138 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 4);
139 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer, inputArray.length);
140 arrayMemoryView.set(inputArray, 1);
141 arrayMemoryView[0] = inputArray.length;
142 return cArrayPointer;
145 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>): number {
146 const cArrayPointer = wasm.TS_malloc(inputArray.length * 8 + 1);
147 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
148 arrayLengthView[0] = inputArray.length;
149 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
150 arrayMemoryView.set(inputArray);
151 return cArrayPointer;
155 export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {
156 if (arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
161 export function getArrayLength(arrayPointer: number): number {
162 const arraySizeViewer = new Uint32Array(wasm.memory.buffer, arrayPointer, 1);
163 return arraySizeViewer[0];
166 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
167 const arraySize = getArrayLength(arrayPointer);
168 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, arraySize);
169 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
170 // will free the underlying memory when it becomes unreachable instead of copying here.
171 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
172 const actualArray = actualArrayViewer.slice(0, arraySize);
174 wasm.TS_free(arrayPointer);
178 const decodeUint32Array = (arrayPointer: number, free = true) => {
179 const arraySize = getArrayLength(arrayPointer);
180 const actualArrayViewer = new Uint32Array(
181 wasm.memory.buffer, // value
182 arrayPointer + 4, // offset (ignoring length bytes)
183 arraySize // uint32 count
185 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
186 // will free the underlying memory when it becomes unreachable instead of copying here.
187 const actualArray = actualArrayViewer.slice(0, arraySize);
189 wasm.TS_free(arrayPointer);
195 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
198 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
199 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
200 return actualArrayViewer[idx];
204 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
205 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
206 return actualArrayViewer[idx];
211 export function encodeString(str: string): number {
212 const charArray = new TextEncoder().encode(str);
213 return encodeUint8Array(charArray);
217 export function decodeString(stringPointer: number, free = true): string {
218 const arraySize = getArrayLength(stringPointer);
219 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 4, arraySize);
220 const result = new TextDecoder("utf-8").decode(memoryView);
223 wasm.TS_free(stringPointer);
229 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
230 /* @internal */ export function debugPrintRemainingAllocs() { }
233 * An error when accessing the chain via [`Access`].
235 export enum AccessError {
237 * The requested chain is unknown.
239 LDKAccessError_UnknownChain,
241 * The requested transaction doesn't exist or hasn't confirmed.
243 LDKAccessError_UnknownTx,
248 * An enum which can either contain a or not
250 export enum COption_NoneZ {
252 * When we're in this state, this COption_NoneZ contains a
254 LDKCOption_NoneZ_Some,
256 * When we're in this state, this COption_NoneZ contains nothing
258 LDKCOption_NoneZ_None,
263 * An error enum representing a failure to persist a channel monitor update.
265 export enum ChannelMonitorUpdateErr {
267 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
268 our state failed, but is expected to succeed at some point in the future).
270 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
271 submitting new commitment transactions to the counterparty. Once the update(s) that failed
272 have been successfully applied, a [`MonitorEvent::UpdateCompleted`] event should be returned
273 via [`Watch::release_pending_monitor_events`] which will then restore the channel to an
276 Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
277 you return a TemporaryFailure you must ensure that it is written to disk safely before
278 writing out the latest ChannelManager state.
280 Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
281 (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
282 to claim it on this channel) and those updates must be applied wherever they can be. At
283 least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
284 be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
285 the channel which would invalidate previous ChannelMonitors are not made when a channel has
288 Note that even if updates made after TemporaryFailure succeed you must still provide a
289 [`MonitorEvent::UpdateCompleted`] to ensure you have the latest monitor and re-enable
290 normal channel operation. Note that this is normally generated through a call to
291 [`ChainMonitor::channel_monitor_updated`].
293 Note that the update being processed here will not be replayed for you when you return a
294 [`MonitorEvent::UpdateCompleted`] event via [`Watch::release_pending_monitor_events`], so
295 you must store the update itself on your own local disk prior to returning a
296 TemporaryFailure. You may, of course, employ a journaling approach, storing only the
297 ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
300 For deployments where a copy of ChannelMonitors and other local state are backed up in a
301 remote location (with local copies persisted immediately), it is anticipated that all
302 updates will return TemporaryFailure until the remote copies could be updated.
304 [`ChainMonitor::channel_monitor_updated`]: chainmonitor::ChainMonitor::channel_monitor_updated
306 LDKChannelMonitorUpdateErr_TemporaryFailure,
308 * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
309 different watchtower and cannot update with all watchtowers that were previously informed
312 At reception of this error, ChannelManager will force-close the channel and return at
313 least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
314 least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
315 update must be rejected.
317 This failure may also signal a failure to update the local persisted copy of one of
318 the channel monitor instance.
320 Note that even when you fail a holder commitment transaction update, you must store the
321 update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
322 broadcasts it (e.g distributed channel-monitor deployment)
324 In case of distributed watchtowers deployment, the new version must be written to disk, as
325 state may have been stored but rejected due to a block forcing a commitment broadcast. This
326 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
327 lagging behind on block processing.
329 LDKChannelMonitorUpdateErr_PermanentFailure,
334 * An enum that represents the speed at which we want a transaction to confirm used for feerate
337 export enum ConfirmationTarget {
339 * We are happy with this transaction confirming slowly when feerate drops some.
341 LDKConfirmationTarget_Background,
343 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
345 LDKConfirmationTarget_Normal,
347 * We'd like this transaction to confirm in the next few blocks.
349 LDKConfirmationTarget_HighPriority,
354 * Errors that may occur when constructing a new `RawInvoice` or `Invoice`
356 export enum CreationError {
358 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
360 LDKCreationError_DescriptionTooLong,
362 * The specified route has too many hops and can't be encoded
364 LDKCreationError_RouteTooLong,
366 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
368 LDKCreationError_TimestampOutOfBounds,
370 * The supplied millisatoshi amount was greater than the total bitcoin supply.
372 LDKCreationError_InvalidAmount,
374 * Route hints were required for this invoice and were missing. Applies to
377 [phantom invoices]: crate::utils::create_phantom_invoice
379 LDKCreationError_MissingRouteHints,
384 * Enum representing the crypto currencies (or networks) supported by this library
386 export enum Currency {
394 LDKCurrency_BitcoinTestnet,
411 * Represents an IO Error. Note that some information is lost in the conversion from Rust.
413 export enum IOError {
415 LDKIOError_PermissionDenied,
416 LDKIOError_ConnectionRefused,
417 LDKIOError_ConnectionReset,
418 LDKIOError_ConnectionAborted,
419 LDKIOError_NotConnected,
420 LDKIOError_AddrInUse,
421 LDKIOError_AddrNotAvailable,
422 LDKIOError_BrokenPipe,
423 LDKIOError_AlreadyExists,
424 LDKIOError_WouldBlock,
425 LDKIOError_InvalidInput,
426 LDKIOError_InvalidData,
428 LDKIOError_WriteZero,
429 LDKIOError_Interrupted,
431 LDKIOError_UnexpectedEof,
436 * An enum representing the available verbosity levels of the logger.
440 * Designates extremely verbose information, including gossip-induced messages
444 * Designates very low priority, often extremely verbose, information
448 * Designates lower priority information
452 * Designates useful information
456 * Designates hazardous situations
460 * Designates very serious errors
467 * An enum representing the possible Bitcoin or test networks which we can run on
469 export enum Network {
471 * The main Bitcoin blockchain.
475 * The testnet3 blockchain.
479 * A local test blockchain.
483 * A blockchain on which blocks are signed instead of mined.
490 * Specifies the recipient of an invoice, to indicate to [`KeysInterface::sign_invoice`] what node
491 * secret key should be used to sign the invoice.
493 export enum Recipient {
495 * The invoice should be signed with the local node secret key.
499 * The invoice should be signed with the phantom node secret key. This secret key must be the
500 same for all nodes participating in the [phantom node payment].
502 [phantom node payment]: PhantomKeysManager
504 LDKRecipient_PhantomNode,
509 * Represents an error returned from libsecp256k1 during validation of some secp256k1 data
511 export enum Secp256k1Error {
513 * Signature failed verification
515 LDKSecp256k1Error_IncorrectSignature,
517 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
519 LDKSecp256k1Error_InvalidMessage,
523 LDKSecp256k1Error_InvalidPublicKey,
527 LDKSecp256k1Error_InvalidSignature,
531 LDKSecp256k1Error_InvalidSecretKey,
535 LDKSecp256k1Error_InvalidSharedSecret,
539 LDKSecp256k1Error_InvalidRecoveryId,
541 * Invalid tweak for add_assign or mul_assign
543 LDKSecp256k1Error_InvalidTweak,
545 * Didn't pass enough memory to context creation with preallocated memory
547 LDKSecp256k1Error_NotEnoughMemory,
549 * Bad set of public keys.
551 LDKSecp256k1Error_InvalidPublicKeySum,
553 * The only valid parity values are 0 or 1.
555 LDKSecp256k1Error_InvalidParityValue,
560 * Errors that may occur when converting a `RawInvoice` to an `Invoice`. They relate to the
561 * requirements sections in BOLT #11
563 export enum SemanticError {
565 * The invoice is missing the mandatory payment hash
567 LDKSemanticError_NoPaymentHash,
569 * The invoice has multiple payment hashes which isn't allowed
571 LDKSemanticError_MultiplePaymentHashes,
573 * No description or description hash are part of the invoice
575 LDKSemanticError_NoDescription,
577 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
579 LDKSemanticError_MultipleDescriptions,
581 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
584 LDKSemanticError_NoPaymentSecret,
586 * The invoice contains multiple payment secrets
588 LDKSemanticError_MultiplePaymentSecrets,
590 * The invoice's features are invalid
592 LDKSemanticError_InvalidFeatures,
594 * The recovery id doesn't fit the signature/pub key
596 LDKSemanticError_InvalidRecoveryId,
598 * The invoice's signature is invalid
600 LDKSemanticError_InvalidSignature,
602 * The invoice's amount was not a whole number of millisatoshis
604 LDKSemanticError_ImpreciseAmount,
609 * SI prefixes for the human readable part
611 export enum SiPrefix {
631 export class LDKBech32Error {
632 protected constructor() {}
635 export function LDKBech32Error_ty_from_ptr(ptr: number): number {
636 if(!isWasmInitialized) {
637 throw new Error("initializeWasm() must be awaited first!");
639 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
640 return nativeResponseValue;
643 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: number): number {
644 if(!isWasmInitialized) {
645 throw new Error("initializeWasm() must be awaited first!");
647 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
648 return nativeResponseValue;
651 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: number): number {
652 if(!isWasmInitialized) {
653 throw new Error("initializeWasm() must be awaited first!");
655 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
656 return nativeResponseValue;
658 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
660 export function TxOut_get_script_pubkey(thing: number): number {
661 if(!isWasmInitialized) {
662 throw new Error("initializeWasm() must be awaited first!");
664 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
665 return nativeResponseValue;
667 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
669 export function TxOut_get_value(thing: number): bigint {
670 if(!isWasmInitialized) {
671 throw new Error("initializeWasm() must be awaited first!");
673 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
674 return nativeResponseValue;
676 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
678 export function CResult_NoneNoneZ_get_ok(owner: number): void {
679 if(!isWasmInitialized) {
680 throw new Error("initializeWasm() must be awaited first!");
682 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
683 // debug statements here
685 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
687 export function CResult_NoneNoneZ_get_err(owner: number): void {
688 if(!isWasmInitialized) {
689 throw new Error("initializeWasm() must be awaited first!");
691 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
692 // debug statements here
694 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
696 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: number): number {
697 if(!isWasmInitialized) {
698 throw new Error("initializeWasm() must be awaited first!");
700 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
701 return nativeResponseValue;
703 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
705 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: number): number {
706 if(!isWasmInitialized) {
707 throw new Error("initializeWasm() must be awaited first!");
709 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
710 return nativeResponseValue;
712 // struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
714 export function CResult_SecretKeyErrorZ_get_ok(owner: number): number {
715 if(!isWasmInitialized) {
716 throw new Error("initializeWasm() must be awaited first!");
718 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_ok(owner);
719 return nativeResponseValue;
721 // enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
723 export function CResult_SecretKeyErrorZ_get_err(owner: number): Secp256k1Error {
724 if(!isWasmInitialized) {
725 throw new Error("initializeWasm() must be awaited first!");
727 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_err(owner);
728 return nativeResponseValue;
730 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
732 export function CResult_PublicKeyErrorZ_get_ok(owner: number): number {
733 if(!isWasmInitialized) {
734 throw new Error("initializeWasm() must be awaited first!");
736 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
737 return nativeResponseValue;
739 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
741 export function CResult_PublicKeyErrorZ_get_err(owner: number): Secp256k1Error {
742 if(!isWasmInitialized) {
743 throw new Error("initializeWasm() must be awaited first!");
745 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
746 return nativeResponseValue;
748 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
750 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: number): number {
751 if(!isWasmInitialized) {
752 throw new Error("initializeWasm() must be awaited first!");
754 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
755 return nativeResponseValue;
757 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
759 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: number): number {
760 if(!isWasmInitialized) {
761 throw new Error("initializeWasm() must be awaited first!");
763 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
764 return nativeResponseValue;
766 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
768 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: number): number {
769 if(!isWasmInitialized) {
770 throw new Error("initializeWasm() must be awaited first!");
772 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
773 return nativeResponseValue;
775 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
777 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: number): number {
778 if(!isWasmInitialized) {
779 throw new Error("initializeWasm() must be awaited first!");
781 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
782 return nativeResponseValue;
784 // struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
786 export function CResult_TxCreationKeysErrorZ_get_ok(owner: number): number {
787 if(!isWasmInitialized) {
788 throw new Error("initializeWasm() must be awaited first!");
790 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_ok(owner);
791 return nativeResponseValue;
793 // enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
795 export function CResult_TxCreationKeysErrorZ_get_err(owner: number): Secp256k1Error {
796 if(!isWasmInitialized) {
797 throw new Error("initializeWasm() must be awaited first!");
799 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_err(owner);
800 return nativeResponseValue;
803 export class LDKCOption_u32Z {
804 protected constructor() {}
807 export function LDKCOption_u32Z_ty_from_ptr(ptr: number): number {
808 if(!isWasmInitialized) {
809 throw new Error("initializeWasm() must be awaited first!");
811 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
812 return nativeResponseValue;
815 export function LDKCOption_u32Z_Some_get_some(ptr: number): number {
816 if(!isWasmInitialized) {
817 throw new Error("initializeWasm() must be awaited first!");
819 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
820 return nativeResponseValue;
822 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
824 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: number): number {
825 if(!isWasmInitialized) {
826 throw new Error("initializeWasm() must be awaited first!");
828 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
829 return nativeResponseValue;
831 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
833 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: number): number {
834 if(!isWasmInitialized) {
835 throw new Error("initializeWasm() must be awaited first!");
837 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
838 return nativeResponseValue;
840 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
842 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
843 if(!isWasmInitialized) {
844 throw new Error("initializeWasm() must be awaited first!");
846 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
847 return nativeResponseValue;
849 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
851 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
852 if(!isWasmInitialized) {
853 throw new Error("initializeWasm() must be awaited first!");
855 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
856 return nativeResponseValue;
858 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
860 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
861 if(!isWasmInitialized) {
862 throw new Error("initializeWasm() must be awaited first!");
864 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
865 return nativeResponseValue;
867 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
869 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
870 if(!isWasmInitialized) {
871 throw new Error("initializeWasm() must be awaited first!");
873 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
874 return nativeResponseValue;
876 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
878 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
879 if(!isWasmInitialized) {
880 throw new Error("initializeWasm() must be awaited first!");
882 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
883 return nativeResponseValue;
885 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
887 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
888 if(!isWasmInitialized) {
889 throw new Error("initializeWasm() must be awaited first!");
891 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
892 return nativeResponseValue;
894 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
896 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
897 if(!isWasmInitialized) {
898 throw new Error("initializeWasm() must be awaited first!");
900 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
901 return nativeResponseValue;
903 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
905 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
906 if(!isWasmInitialized) {
907 throw new Error("initializeWasm() must be awaited first!");
909 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
910 return nativeResponseValue;
912 // struct LDKTrustedClosingTransaction *CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
914 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: number): number {
915 if(!isWasmInitialized) {
916 throw new Error("initializeWasm() must be awaited first!");
918 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
919 return nativeResponseValue;
921 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
923 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: number): void {
924 if(!isWasmInitialized) {
925 throw new Error("initializeWasm() must be awaited first!");
927 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
928 // debug statements here
930 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
932 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
933 if(!isWasmInitialized) {
934 throw new Error("initializeWasm() must be awaited first!");
936 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
937 return nativeResponseValue;
939 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
941 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
942 if(!isWasmInitialized) {
943 throw new Error("initializeWasm() must be awaited first!");
945 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
946 return nativeResponseValue;
948 // struct LDKTrustedCommitmentTransaction *CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
950 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: number): number {
951 if(!isWasmInitialized) {
952 throw new Error("initializeWasm() must be awaited first!");
954 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
955 return nativeResponseValue;
957 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
959 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: number): void {
960 if(!isWasmInitialized) {
961 throw new Error("initializeWasm() must be awaited first!");
963 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
964 // debug statements here
966 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
968 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: number): number {
969 if(!isWasmInitialized) {
970 throw new Error("initializeWasm() must be awaited first!");
972 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
973 return nativeResponseValue;
975 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
977 export function CResult_CVec_SignatureZNoneZ_get_err(owner: number): void {
978 if(!isWasmInitialized) {
979 throw new Error("initializeWasm() must be awaited first!");
981 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
982 // debug statements here
984 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
986 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: number): number {
987 if(!isWasmInitialized) {
988 throw new Error("initializeWasm() must be awaited first!");
990 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
991 return nativeResponseValue;
993 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
995 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: number): number {
996 if(!isWasmInitialized) {
997 throw new Error("initializeWasm() must be awaited first!");
999 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
1000 return nativeResponseValue;
1002 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1004 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: number): number {
1005 if(!isWasmInitialized) {
1006 throw new Error("initializeWasm() must be awaited first!");
1008 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
1009 return nativeResponseValue;
1011 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
1013 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: number): number {
1014 if(!isWasmInitialized) {
1015 throw new Error("initializeWasm() must be awaited first!");
1017 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
1018 return nativeResponseValue;
1020 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1022 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: number): number {
1023 if(!isWasmInitialized) {
1024 throw new Error("initializeWasm() must be awaited first!");
1026 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
1027 return nativeResponseValue;
1029 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1031 export function CResult_RouteHopDecodeErrorZ_get_err(owner: number): number {
1032 if(!isWasmInitialized) {
1033 throw new Error("initializeWasm() must be awaited first!");
1035 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
1036 return nativeResponseValue;
1038 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1040 export function CResult_RouteDecodeErrorZ_get_ok(owner: number): number {
1041 if(!isWasmInitialized) {
1042 throw new Error("initializeWasm() must be awaited first!");
1044 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
1045 return nativeResponseValue;
1047 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1049 export function CResult_RouteDecodeErrorZ_get_err(owner: number): number {
1050 if(!isWasmInitialized) {
1051 throw new Error("initializeWasm() must be awaited first!");
1053 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
1054 return nativeResponseValue;
1056 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1058 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: number): number {
1059 if(!isWasmInitialized) {
1060 throw new Error("initializeWasm() must be awaited first!");
1062 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
1063 return nativeResponseValue;
1065 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1067 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: number): number {
1068 if(!isWasmInitialized) {
1069 throw new Error("initializeWasm() must be awaited first!");
1071 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
1072 return nativeResponseValue;
1075 export class LDKCOption_u64Z {
1076 protected constructor() {}
1079 export function LDKCOption_u64Z_ty_from_ptr(ptr: number): number {
1080 if(!isWasmInitialized) {
1081 throw new Error("initializeWasm() must be awaited first!");
1083 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1084 return nativeResponseValue;
1087 export function LDKCOption_u64Z_Some_get_some(ptr: number): bigint {
1088 if(!isWasmInitialized) {
1089 throw new Error("initializeWasm() must be awaited first!");
1091 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1092 return nativeResponseValue;
1094 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1096 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: number): number {
1097 if(!isWasmInitialized) {
1098 throw new Error("initializeWasm() must be awaited first!");
1100 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
1101 return nativeResponseValue;
1103 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1105 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: number): number {
1106 if(!isWasmInitialized) {
1107 throw new Error("initializeWasm() must be awaited first!");
1109 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
1110 return nativeResponseValue;
1112 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1114 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: number): number {
1115 if(!isWasmInitialized) {
1116 throw new Error("initializeWasm() must be awaited first!");
1118 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
1119 return nativeResponseValue;
1121 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1123 export function CResult_RouteHintDecodeErrorZ_get_err(owner: number): number {
1124 if(!isWasmInitialized) {
1125 throw new Error("initializeWasm() must be awaited first!");
1127 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
1128 return nativeResponseValue;
1130 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1132 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: number): number {
1133 if(!isWasmInitialized) {
1134 throw new Error("initializeWasm() must be awaited first!");
1136 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
1137 return nativeResponseValue;
1139 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1141 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: number): number {
1142 if(!isWasmInitialized) {
1143 throw new Error("initializeWasm() must be awaited first!");
1145 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
1146 return nativeResponseValue;
1148 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1150 export function CResult_RouteLightningErrorZ_get_ok(owner: number): number {
1151 if(!isWasmInitialized) {
1152 throw new Error("initializeWasm() must be awaited first!");
1154 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
1155 return nativeResponseValue;
1157 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1159 export function CResult_RouteLightningErrorZ_get_err(owner: number): number {
1160 if(!isWasmInitialized) {
1161 throw new Error("initializeWasm() must be awaited first!");
1163 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
1164 return nativeResponseValue;
1167 export class LDKPaymentPurpose {
1168 protected constructor() {}
1171 export function LDKPaymentPurpose_ty_from_ptr(ptr: number): number {
1172 if(!isWasmInitialized) {
1173 throw new Error("initializeWasm() must be awaited first!");
1175 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1176 return nativeResponseValue;
1179 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: number): number {
1180 if(!isWasmInitialized) {
1181 throw new Error("initializeWasm() must be awaited first!");
1183 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1184 return nativeResponseValue;
1187 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: number): number {
1188 if(!isWasmInitialized) {
1189 throw new Error("initializeWasm() must be awaited first!");
1191 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1192 return nativeResponseValue;
1195 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: number): number {
1196 if(!isWasmInitialized) {
1197 throw new Error("initializeWasm() must be awaited first!");
1199 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1200 return nativeResponseValue;
1202 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1204 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: number): number {
1205 if(!isWasmInitialized) {
1206 throw new Error("initializeWasm() must be awaited first!");
1208 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
1209 return nativeResponseValue;
1211 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1213 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: number): number {
1214 if(!isWasmInitialized) {
1215 throw new Error("initializeWasm() must be awaited first!");
1217 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
1218 return nativeResponseValue;
1221 export class LDKClosureReason {
1222 protected constructor() {}
1225 export function LDKClosureReason_ty_from_ptr(ptr: number): number {
1226 if(!isWasmInitialized) {
1227 throw new Error("initializeWasm() must be awaited first!");
1229 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1230 return nativeResponseValue;
1233 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: number): number {
1234 if(!isWasmInitialized) {
1235 throw new Error("initializeWasm() must be awaited first!");
1237 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1238 return nativeResponseValue;
1241 export function LDKClosureReason_ProcessingError_get_err(ptr: number): number {
1242 if(!isWasmInitialized) {
1243 throw new Error("initializeWasm() must be awaited first!");
1245 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1246 return nativeResponseValue;
1249 export class LDKCOption_ClosureReasonZ {
1250 protected constructor() {}
1253 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: number): number {
1254 if(!isWasmInitialized) {
1255 throw new Error("initializeWasm() must be awaited first!");
1257 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
1258 return nativeResponseValue;
1261 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: number): number {
1262 if(!isWasmInitialized) {
1263 throw new Error("initializeWasm() must be awaited first!");
1265 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
1266 return nativeResponseValue;
1268 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1270 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: number): number {
1271 if(!isWasmInitialized) {
1272 throw new Error("initializeWasm() must be awaited first!");
1274 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
1275 return nativeResponseValue;
1277 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1279 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: number): number {
1280 if(!isWasmInitialized) {
1281 throw new Error("initializeWasm() must be awaited first!");
1283 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
1284 return nativeResponseValue;
1287 export class LDKNetworkUpdate {
1288 protected constructor() {}
1291 export function LDKNetworkUpdate_ty_from_ptr(ptr: number): number {
1292 if(!isWasmInitialized) {
1293 throw new Error("initializeWasm() must be awaited first!");
1295 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1296 return nativeResponseValue;
1299 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: number): number {
1300 if(!isWasmInitialized) {
1301 throw new Error("initializeWasm() must be awaited first!");
1303 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1304 return nativeResponseValue;
1307 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: number): bigint {
1308 if(!isWasmInitialized) {
1309 throw new Error("initializeWasm() must be awaited first!");
1311 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
1312 return nativeResponseValue;
1315 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: number): boolean {
1316 if(!isWasmInitialized) {
1317 throw new Error("initializeWasm() must be awaited first!");
1319 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
1320 return nativeResponseValue;
1323 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: number): number {
1324 if(!isWasmInitialized) {
1325 throw new Error("initializeWasm() must be awaited first!");
1327 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1328 return nativeResponseValue;
1331 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: number): boolean {
1332 if(!isWasmInitialized) {
1333 throw new Error("initializeWasm() must be awaited first!");
1335 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1336 return nativeResponseValue;
1339 export class LDKCOption_NetworkUpdateZ {
1340 protected constructor() {}
1343 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: number): number {
1344 if(!isWasmInitialized) {
1345 throw new Error("initializeWasm() must be awaited first!");
1347 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1348 return nativeResponseValue;
1351 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: number): number {
1352 if(!isWasmInitialized) {
1353 throw new Error("initializeWasm() must be awaited first!");
1355 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1356 return nativeResponseValue;
1359 export class LDKSpendableOutputDescriptor {
1360 protected constructor() {}
1363 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: number): number {
1364 if(!isWasmInitialized) {
1365 throw new Error("initializeWasm() must be awaited first!");
1367 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1368 return nativeResponseValue;
1371 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: number): number {
1372 if(!isWasmInitialized) {
1373 throw new Error("initializeWasm() must be awaited first!");
1375 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1376 return nativeResponseValue;
1379 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: number): number {
1380 if(!isWasmInitialized) {
1381 throw new Error("initializeWasm() must be awaited first!");
1383 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1384 return nativeResponseValue;
1387 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: number): number {
1388 if(!isWasmInitialized) {
1389 throw new Error("initializeWasm() must be awaited first!");
1391 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1392 return nativeResponseValue;
1395 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: number): number {
1396 if(!isWasmInitialized) {
1397 throw new Error("initializeWasm() must be awaited first!");
1399 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1400 return nativeResponseValue;
1403 export class LDKEvent {
1404 protected constructor() {}
1407 export function LDKEvent_ty_from_ptr(ptr: number): number {
1408 if(!isWasmInitialized) {
1409 throw new Error("initializeWasm() must be awaited first!");
1411 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1412 return nativeResponseValue;
1415 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: number): number {
1416 if(!isWasmInitialized) {
1417 throw new Error("initializeWasm() must be awaited first!");
1419 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1420 return nativeResponseValue;
1423 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: number): number {
1424 if(!isWasmInitialized) {
1425 throw new Error("initializeWasm() must be awaited first!");
1427 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
1428 return nativeResponseValue;
1431 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: number): bigint {
1432 if(!isWasmInitialized) {
1433 throw new Error("initializeWasm() must be awaited first!");
1435 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1436 return nativeResponseValue;
1439 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: number): number {
1440 if(!isWasmInitialized) {
1441 throw new Error("initializeWasm() must be awaited first!");
1443 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1444 return nativeResponseValue;
1447 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: number): bigint {
1448 if(!isWasmInitialized) {
1449 throw new Error("initializeWasm() must be awaited first!");
1451 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1452 return nativeResponseValue;
1455 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: number): number {
1456 if(!isWasmInitialized) {
1457 throw new Error("initializeWasm() must be awaited first!");
1459 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1460 return nativeResponseValue;
1463 export function LDKEvent_PaymentReceived_get_amount_msat(ptr: number): bigint {
1464 if(!isWasmInitialized) {
1465 throw new Error("initializeWasm() must be awaited first!");
1467 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amount_msat(ptr);
1468 return nativeResponseValue;
1471 export function LDKEvent_PaymentReceived_get_purpose(ptr: number): number {
1472 if(!isWasmInitialized) {
1473 throw new Error("initializeWasm() must be awaited first!");
1475 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1476 return nativeResponseValue;
1479 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: number): number {
1480 if(!isWasmInitialized) {
1481 throw new Error("initializeWasm() must be awaited first!");
1483 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
1484 return nativeResponseValue;
1487 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: number): bigint {
1488 if(!isWasmInitialized) {
1489 throw new Error("initializeWasm() must be awaited first!");
1491 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
1492 return nativeResponseValue;
1495 export function LDKEvent_PaymentClaimed_get_purpose(ptr: number): number {
1496 if(!isWasmInitialized) {
1497 throw new Error("initializeWasm() must be awaited first!");
1499 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
1500 return nativeResponseValue;
1503 export function LDKEvent_PaymentSent_get_payment_id(ptr: number): number {
1504 if(!isWasmInitialized) {
1505 throw new Error("initializeWasm() must be awaited first!");
1507 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1508 return nativeResponseValue;
1511 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: number): number {
1512 if(!isWasmInitialized) {
1513 throw new Error("initializeWasm() must be awaited first!");
1515 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1516 return nativeResponseValue;
1519 export function LDKEvent_PaymentSent_get_payment_hash(ptr: number): number {
1520 if(!isWasmInitialized) {
1521 throw new Error("initializeWasm() must be awaited first!");
1523 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1524 return nativeResponseValue;
1527 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: number): number {
1528 if(!isWasmInitialized) {
1529 throw new Error("initializeWasm() must be awaited first!");
1531 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1532 return nativeResponseValue;
1535 export function LDKEvent_PaymentFailed_get_payment_id(ptr: number): number {
1536 if(!isWasmInitialized) {
1537 throw new Error("initializeWasm() must be awaited first!");
1539 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1540 return nativeResponseValue;
1543 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: number): number {
1544 if(!isWasmInitialized) {
1545 throw new Error("initializeWasm() must be awaited first!");
1547 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1548 return nativeResponseValue;
1551 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: number): number {
1552 if(!isWasmInitialized) {
1553 throw new Error("initializeWasm() must be awaited first!");
1555 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1556 return nativeResponseValue;
1559 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: number): number {
1560 if(!isWasmInitialized) {
1561 throw new Error("initializeWasm() must be awaited first!");
1563 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1564 return nativeResponseValue;
1567 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: number): number {
1568 if(!isWasmInitialized) {
1569 throw new Error("initializeWasm() must be awaited first!");
1571 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1572 return nativeResponseValue;
1575 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: number): number {
1576 if(!isWasmInitialized) {
1577 throw new Error("initializeWasm() must be awaited first!");
1579 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1580 return nativeResponseValue;
1583 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: number): number {
1584 if(!isWasmInitialized) {
1585 throw new Error("initializeWasm() must be awaited first!");
1587 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1588 return nativeResponseValue;
1591 export function LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr: number): boolean {
1592 if(!isWasmInitialized) {
1593 throw new Error("initializeWasm() must be awaited first!");
1595 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr);
1596 return nativeResponseValue;
1599 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: number): number {
1600 if(!isWasmInitialized) {
1601 throw new Error("initializeWasm() must be awaited first!");
1603 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1604 return nativeResponseValue;
1607 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: number): boolean {
1608 if(!isWasmInitialized) {
1609 throw new Error("initializeWasm() must be awaited first!");
1611 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1612 return nativeResponseValue;
1615 export function LDKEvent_PaymentPathFailed_get_path(ptr: number): number {
1616 if(!isWasmInitialized) {
1617 throw new Error("initializeWasm() must be awaited first!");
1619 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1620 return nativeResponseValue;
1623 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: number): number {
1624 if(!isWasmInitialized) {
1625 throw new Error("initializeWasm() must be awaited first!");
1627 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1628 return nativeResponseValue;
1631 export function LDKEvent_PaymentPathFailed_get_retry(ptr: number): number {
1632 if(!isWasmInitialized) {
1633 throw new Error("initializeWasm() must be awaited first!");
1635 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1636 return nativeResponseValue;
1639 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: number): bigint {
1640 if(!isWasmInitialized) {
1641 throw new Error("initializeWasm() must be awaited first!");
1643 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1644 return nativeResponseValue;
1647 export function LDKEvent_SpendableOutputs_get_outputs(ptr: number): number {
1648 if(!isWasmInitialized) {
1649 throw new Error("initializeWasm() must be awaited first!");
1651 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1652 return nativeResponseValue;
1655 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: number): number {
1656 if(!isWasmInitialized) {
1657 throw new Error("initializeWasm() must be awaited first!");
1659 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
1660 return nativeResponseValue;
1663 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: number): number {
1664 if(!isWasmInitialized) {
1665 throw new Error("initializeWasm() must be awaited first!");
1667 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
1668 return nativeResponseValue;
1671 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: number): number {
1672 if(!isWasmInitialized) {
1673 throw new Error("initializeWasm() must be awaited first!");
1675 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1676 return nativeResponseValue;
1679 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: number): boolean {
1680 if(!isWasmInitialized) {
1681 throw new Error("initializeWasm() must be awaited first!");
1683 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1684 return nativeResponseValue;
1687 export function LDKEvent_ChannelClosed_get_channel_id(ptr: number): number {
1688 if(!isWasmInitialized) {
1689 throw new Error("initializeWasm() must be awaited first!");
1691 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1692 return nativeResponseValue;
1695 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: number): bigint {
1696 if(!isWasmInitialized) {
1697 throw new Error("initializeWasm() must be awaited first!");
1699 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1700 return nativeResponseValue;
1703 export function LDKEvent_ChannelClosed_get_reason(ptr: number): number {
1704 if(!isWasmInitialized) {
1705 throw new Error("initializeWasm() must be awaited first!");
1707 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1708 return nativeResponseValue;
1711 export function LDKEvent_DiscardFunding_get_channel_id(ptr: number): number {
1712 if(!isWasmInitialized) {
1713 throw new Error("initializeWasm() must be awaited first!");
1715 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1716 return nativeResponseValue;
1719 export function LDKEvent_DiscardFunding_get_transaction(ptr: number): number {
1720 if(!isWasmInitialized) {
1721 throw new Error("initializeWasm() must be awaited first!");
1723 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
1724 return nativeResponseValue;
1727 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: number): number {
1728 if(!isWasmInitialized) {
1729 throw new Error("initializeWasm() must be awaited first!");
1731 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
1732 return nativeResponseValue;
1735 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: number): number {
1736 if(!isWasmInitialized) {
1737 throw new Error("initializeWasm() must be awaited first!");
1739 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
1740 return nativeResponseValue;
1743 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: number): bigint {
1744 if(!isWasmInitialized) {
1745 throw new Error("initializeWasm() must be awaited first!");
1747 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
1748 return nativeResponseValue;
1751 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: number): bigint {
1752 if(!isWasmInitialized) {
1753 throw new Error("initializeWasm() must be awaited first!");
1755 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
1756 return nativeResponseValue;
1759 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: number): number {
1760 if(!isWasmInitialized) {
1761 throw new Error("initializeWasm() must be awaited first!");
1763 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
1764 return nativeResponseValue;
1767 export class LDKCOption_EventZ {
1768 protected constructor() {}
1771 export function LDKCOption_EventZ_ty_from_ptr(ptr: number): number {
1772 if(!isWasmInitialized) {
1773 throw new Error("initializeWasm() must be awaited first!");
1775 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
1776 return nativeResponseValue;
1779 export function LDKCOption_EventZ_Some_get_some(ptr: number): number {
1780 if(!isWasmInitialized) {
1781 throw new Error("initializeWasm() must be awaited first!");
1783 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
1784 return nativeResponseValue;
1786 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1788 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: number): number {
1789 if(!isWasmInitialized) {
1790 throw new Error("initializeWasm() must be awaited first!");
1792 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
1793 return nativeResponseValue;
1795 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1797 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: number): number {
1798 if(!isWasmInitialized) {
1799 throw new Error("initializeWasm() must be awaited first!");
1801 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
1802 return nativeResponseValue;
1805 export class LDKErrorAction {
1806 protected constructor() {}
1809 export function LDKErrorAction_ty_from_ptr(ptr: number): number {
1810 if(!isWasmInitialized) {
1811 throw new Error("initializeWasm() must be awaited first!");
1813 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
1814 return nativeResponseValue;
1817 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: number): number {
1818 if(!isWasmInitialized) {
1819 throw new Error("initializeWasm() must be awaited first!");
1821 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
1822 return nativeResponseValue;
1825 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: number): Level {
1826 if(!isWasmInitialized) {
1827 throw new Error("initializeWasm() must be awaited first!");
1829 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
1830 return nativeResponseValue;
1833 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: number): number {
1834 if(!isWasmInitialized) {
1835 throw new Error("initializeWasm() must be awaited first!");
1837 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
1838 return nativeResponseValue;
1841 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: number): number {
1842 if(!isWasmInitialized) {
1843 throw new Error("initializeWasm() must be awaited first!");
1845 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
1846 return nativeResponseValue;
1849 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: number): Level {
1850 if(!isWasmInitialized) {
1851 throw new Error("initializeWasm() must be awaited first!");
1853 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
1854 return nativeResponseValue;
1857 export class LDKMessageSendEvent {
1858 protected constructor() {}
1861 export function LDKMessageSendEvent_ty_from_ptr(ptr: number): number {
1862 if(!isWasmInitialized) {
1863 throw new Error("initializeWasm() must be awaited first!");
1865 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
1866 return nativeResponseValue;
1869 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: number): number {
1870 if(!isWasmInitialized) {
1871 throw new Error("initializeWasm() must be awaited first!");
1873 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
1874 return nativeResponseValue;
1877 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: number): number {
1878 if(!isWasmInitialized) {
1879 throw new Error("initializeWasm() must be awaited first!");
1881 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
1882 return nativeResponseValue;
1885 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: number): number {
1886 if(!isWasmInitialized) {
1887 throw new Error("initializeWasm() must be awaited first!");
1889 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
1890 return nativeResponseValue;
1893 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: number): number {
1894 if(!isWasmInitialized) {
1895 throw new Error("initializeWasm() must be awaited first!");
1897 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
1898 return nativeResponseValue;
1901 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: number): number {
1902 if(!isWasmInitialized) {
1903 throw new Error("initializeWasm() must be awaited first!");
1905 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
1906 return nativeResponseValue;
1909 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: number): number {
1910 if(!isWasmInitialized) {
1911 throw new Error("initializeWasm() must be awaited first!");
1913 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
1914 return nativeResponseValue;
1917 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: number): number {
1918 if(!isWasmInitialized) {
1919 throw new Error("initializeWasm() must be awaited first!");
1921 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
1922 return nativeResponseValue;
1925 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: number): number {
1926 if(!isWasmInitialized) {
1927 throw new Error("initializeWasm() must be awaited first!");
1929 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
1930 return nativeResponseValue;
1933 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: number): number {
1934 if(!isWasmInitialized) {
1935 throw new Error("initializeWasm() must be awaited first!");
1937 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
1938 return nativeResponseValue;
1941 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: number): number {
1942 if(!isWasmInitialized) {
1943 throw new Error("initializeWasm() must be awaited first!");
1945 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
1946 return nativeResponseValue;
1949 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: number): number {
1950 if(!isWasmInitialized) {
1951 throw new Error("initializeWasm() must be awaited first!");
1953 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
1954 return nativeResponseValue;
1957 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: number): number {
1958 if(!isWasmInitialized) {
1959 throw new Error("initializeWasm() must be awaited first!");
1961 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
1962 return nativeResponseValue;
1965 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: number): number {
1966 if(!isWasmInitialized) {
1967 throw new Error("initializeWasm() must be awaited first!");
1969 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
1970 return nativeResponseValue;
1973 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: number): number {
1974 if(!isWasmInitialized) {
1975 throw new Error("initializeWasm() must be awaited first!");
1977 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
1978 return nativeResponseValue;
1981 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: number): number {
1982 if(!isWasmInitialized) {
1983 throw new Error("initializeWasm() must be awaited first!");
1985 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
1986 return nativeResponseValue;
1989 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: number): number {
1990 if(!isWasmInitialized) {
1991 throw new Error("initializeWasm() must be awaited first!");
1993 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
1994 return nativeResponseValue;
1997 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: number): number {
1998 if(!isWasmInitialized) {
1999 throw new Error("initializeWasm() must be awaited first!");
2001 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
2002 return nativeResponseValue;
2005 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: number): number {
2006 if(!isWasmInitialized) {
2007 throw new Error("initializeWasm() must be awaited first!");
2009 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
2010 return nativeResponseValue;
2013 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: number): number {
2014 if(!isWasmInitialized) {
2015 throw new Error("initializeWasm() must be awaited first!");
2017 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
2018 return nativeResponseValue;
2021 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: number): number {
2022 if(!isWasmInitialized) {
2023 throw new Error("initializeWasm() must be awaited first!");
2025 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
2026 return nativeResponseValue;
2029 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: number): number {
2030 if(!isWasmInitialized) {
2031 throw new Error("initializeWasm() must be awaited first!");
2033 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2034 return nativeResponseValue;
2037 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: number): number {
2038 if(!isWasmInitialized) {
2039 throw new Error("initializeWasm() must be awaited first!");
2041 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2042 return nativeResponseValue;
2045 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: number): number {
2046 if(!isWasmInitialized) {
2047 throw new Error("initializeWasm() must be awaited first!");
2049 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2050 return nativeResponseValue;
2053 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: number): number {
2054 if(!isWasmInitialized) {
2055 throw new Error("initializeWasm() must be awaited first!");
2057 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2058 return nativeResponseValue;
2061 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: number): number {
2062 if(!isWasmInitialized) {
2063 throw new Error("initializeWasm() must be awaited first!");
2065 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
2066 return nativeResponseValue;
2069 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: number): number {
2070 if(!isWasmInitialized) {
2071 throw new Error("initializeWasm() must be awaited first!");
2073 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2074 return nativeResponseValue;
2077 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: number): number {
2078 if(!isWasmInitialized) {
2079 throw new Error("initializeWasm() must be awaited first!");
2081 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2082 return nativeResponseValue;
2085 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: number): number {
2086 if(!isWasmInitialized) {
2087 throw new Error("initializeWasm() must be awaited first!");
2089 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2090 return nativeResponseValue;
2093 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: number): number {
2094 if(!isWasmInitialized) {
2095 throw new Error("initializeWasm() must be awaited first!");
2097 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2098 return nativeResponseValue;
2101 export function LDKMessageSendEvent_HandleError_get_action(ptr: number): number {
2102 if(!isWasmInitialized) {
2103 throw new Error("initializeWasm() must be awaited first!");
2105 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2106 return nativeResponseValue;
2109 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: number): number {
2110 if(!isWasmInitialized) {
2111 throw new Error("initializeWasm() must be awaited first!");
2113 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2114 return nativeResponseValue;
2117 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: number): number {
2118 if(!isWasmInitialized) {
2119 throw new Error("initializeWasm() must be awaited first!");
2121 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2122 return nativeResponseValue;
2125 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: number): number {
2126 if(!isWasmInitialized) {
2127 throw new Error("initializeWasm() must be awaited first!");
2129 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2130 return nativeResponseValue;
2133 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: number): number {
2134 if(!isWasmInitialized) {
2135 throw new Error("initializeWasm() must be awaited first!");
2137 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2138 return nativeResponseValue;
2141 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: number): number {
2142 if(!isWasmInitialized) {
2143 throw new Error("initializeWasm() must be awaited first!");
2145 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2146 return nativeResponseValue;
2149 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: number): number {
2150 if(!isWasmInitialized) {
2151 throw new Error("initializeWasm() must be awaited first!");
2153 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2154 return nativeResponseValue;
2157 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: number): number {
2158 if(!isWasmInitialized) {
2159 throw new Error("initializeWasm() must be awaited first!");
2161 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
2162 return nativeResponseValue;
2165 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: number): number {
2166 if(!isWasmInitialized) {
2167 throw new Error("initializeWasm() must be awaited first!");
2169 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
2170 return nativeResponseValue;
2172 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2174 export function CResult_TxOutAccessErrorZ_get_ok(owner: number): number {
2175 if(!isWasmInitialized) {
2176 throw new Error("initializeWasm() must be awaited first!");
2178 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
2179 return nativeResponseValue;
2181 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2183 export function CResult_TxOutAccessErrorZ_get_err(owner: number): AccessError {
2184 if(!isWasmInitialized) {
2185 throw new Error("initializeWasm() must be awaited first!");
2187 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
2188 return nativeResponseValue;
2190 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2192 export function C2Tuple_usizeTransactionZ_get_a(owner: number): number {
2193 if(!isWasmInitialized) {
2194 throw new Error("initializeWasm() must be awaited first!");
2196 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2197 return nativeResponseValue;
2199 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2201 export function C2Tuple_usizeTransactionZ_get_b(owner: number): number {
2202 if(!isWasmInitialized) {
2203 throw new Error("initializeWasm() must be awaited first!");
2205 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2206 return nativeResponseValue;
2208 // void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2210 export function CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner: number): void {
2211 if(!isWasmInitialized) {
2212 throw new Error("initializeWasm() must be awaited first!");
2214 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner);
2215 // debug statements here
2217 // enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2219 export function CResult_NoneChannelMonitorUpdateErrZ_get_err(owner: number): ChannelMonitorUpdateErr {
2220 if(!isWasmInitialized) {
2221 throw new Error("initializeWasm() must be awaited first!");
2223 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(owner);
2224 return nativeResponseValue;
2227 export class LDKMonitorEvent {
2228 protected constructor() {}
2231 export function LDKMonitorEvent_ty_from_ptr(ptr: number): number {
2232 if(!isWasmInitialized) {
2233 throw new Error("initializeWasm() must be awaited first!");
2235 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2236 return nativeResponseValue;
2239 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: number): number {
2240 if(!isWasmInitialized) {
2241 throw new Error("initializeWasm() must be awaited first!");
2243 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2244 return nativeResponseValue;
2247 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: number): number {
2248 if(!isWasmInitialized) {
2249 throw new Error("initializeWasm() must be awaited first!");
2251 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
2252 return nativeResponseValue;
2255 export function LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr: number): number {
2256 if(!isWasmInitialized) {
2257 throw new Error("initializeWasm() must be awaited first!");
2259 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr);
2260 return nativeResponseValue;
2263 export function LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr: number): bigint {
2264 if(!isWasmInitialized) {
2265 throw new Error("initializeWasm() must be awaited first!");
2267 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr);
2268 return nativeResponseValue;
2271 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: number): number {
2272 if(!isWasmInitialized) {
2273 throw new Error("initializeWasm() must be awaited first!");
2275 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
2276 return nativeResponseValue;
2278 // struct LDKOutPoint C2Tuple_OutPointCVec_MonitorEventZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR owner);
2280 export function C2Tuple_OutPointCVec_MonitorEventZZ_get_a(owner: number): number {
2281 if(!isWasmInitialized) {
2282 throw new Error("initializeWasm() must be awaited first!");
2284 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_get_a(owner);
2285 return nativeResponseValue;
2287 // struct LDKCVec_MonitorEventZ C2Tuple_OutPointCVec_MonitorEventZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR owner);
2289 export function C2Tuple_OutPointCVec_MonitorEventZZ_get_b(owner: number): number {
2290 if(!isWasmInitialized) {
2291 throw new Error("initializeWasm() must be awaited first!");
2293 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_get_b(owner);
2294 return nativeResponseValue;
2297 export class LDKCOption_C2Tuple_usizeTransactionZZ {
2298 protected constructor() {}
2301 export function LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr: number): number {
2302 if(!isWasmInitialized) {
2303 throw new Error("initializeWasm() must be awaited first!");
2305 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr);
2306 return nativeResponseValue;
2309 export function LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr: number): number {
2310 if(!isWasmInitialized) {
2311 throw new Error("initializeWasm() must be awaited first!");
2313 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr);
2314 return nativeResponseValue;
2316 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2318 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: number): number {
2319 if(!isWasmInitialized) {
2320 throw new Error("initializeWasm() must be awaited first!");
2322 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2323 return nativeResponseValue;
2325 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2327 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: number): number {
2328 if(!isWasmInitialized) {
2329 throw new Error("initializeWasm() must be awaited first!");
2331 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2332 return nativeResponseValue;
2334 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2336 export function C2Tuple_u64u64Z_get_a(owner: number): bigint {
2337 if(!isWasmInitialized) {
2338 throw new Error("initializeWasm() must be awaited first!");
2340 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2341 return nativeResponseValue;
2343 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2345 export function C2Tuple_u64u64Z_get_b(owner: number): bigint {
2346 if(!isWasmInitialized) {
2347 throw new Error("initializeWasm() must be awaited first!");
2349 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2350 return nativeResponseValue;
2353 export class LDKCOption_C2Tuple_u64u64ZZ {
2354 protected constructor() {}
2357 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: number): number {
2358 if(!isWasmInitialized) {
2359 throw new Error("initializeWasm() must be awaited first!");
2361 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2362 return nativeResponseValue;
2365 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: number): number {
2366 if(!isWasmInitialized) {
2367 throw new Error("initializeWasm() must be awaited first!");
2369 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2370 return nativeResponseValue;
2373 export interface LDKLogger {
2374 log (record: number): void;
2378 export function LDKLogger_new(impl: LDKLogger): number {
2379 if(!isWasmInitialized) {
2380 throw new Error("initializeWasm() must be awaited first!");
2382 var new_obj_idx = js_objs.length;
2383 for (var i = 0; i < js_objs.length; i++) {
2384 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2386 js_objs[i] = new WeakRef(impl);
2387 return wasm.TS_LDKLogger_new(i);
2389 // struct LDKProbabilisticScorer *CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2391 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: number): number {
2392 if(!isWasmInitialized) {
2393 throw new Error("initializeWasm() must be awaited first!");
2395 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2396 return nativeResponseValue;
2398 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2400 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: number): number {
2401 if(!isWasmInitialized) {
2402 throw new Error("initializeWasm() must be awaited first!");
2404 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2405 return nativeResponseValue;
2407 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2409 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: number): number {
2410 if(!isWasmInitialized) {
2411 throw new Error("initializeWasm() must be awaited first!");
2413 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2414 return nativeResponseValue;
2416 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2418 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: number): number {
2419 if(!isWasmInitialized) {
2420 throw new Error("initializeWasm() must be awaited first!");
2422 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2423 return nativeResponseValue;
2425 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2427 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: number): number {
2428 if(!isWasmInitialized) {
2429 throw new Error("initializeWasm() must be awaited first!");
2431 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2432 return nativeResponseValue;
2434 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2436 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: number): number {
2437 if(!isWasmInitialized) {
2438 throw new Error("initializeWasm() must be awaited first!");
2440 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2441 return nativeResponseValue;
2443 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2445 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2446 if(!isWasmInitialized) {
2447 throw new Error("initializeWasm() must be awaited first!");
2449 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2450 return nativeResponseValue;
2452 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2454 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: number): number {
2455 if(!isWasmInitialized) {
2456 throw new Error("initializeWasm() must be awaited first!");
2458 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2459 return nativeResponseValue;
2461 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2463 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: number): number {
2464 if(!isWasmInitialized) {
2465 throw new Error("initializeWasm() must be awaited first!");
2467 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2468 return nativeResponseValue;
2470 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2472 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: number): number {
2473 if(!isWasmInitialized) {
2474 throw new Error("initializeWasm() must be awaited first!");
2476 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2477 return nativeResponseValue;
2479 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2481 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2482 if(!isWasmInitialized) {
2483 throw new Error("initializeWasm() must be awaited first!");
2485 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2486 return nativeResponseValue;
2488 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2490 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: number): number {
2491 if(!isWasmInitialized) {
2492 throw new Error("initializeWasm() must be awaited first!");
2494 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2495 return nativeResponseValue;
2497 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2499 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: number): number {
2500 if(!isWasmInitialized) {
2501 throw new Error("initializeWasm() must be awaited first!");
2503 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2504 return nativeResponseValue;
2506 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2508 export function CResult_NodeIdDecodeErrorZ_get_err(owner: number): number {
2509 if(!isWasmInitialized) {
2510 throw new Error("initializeWasm() must be awaited first!");
2512 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2513 return nativeResponseValue;
2515 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2517 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: number): number {
2518 if(!isWasmInitialized) {
2519 throw new Error("initializeWasm() must be awaited first!");
2521 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2522 return nativeResponseValue;
2524 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2526 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: number): number {
2527 if(!isWasmInitialized) {
2528 throw new Error("initializeWasm() must be awaited first!");
2530 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2531 return nativeResponseValue;
2534 export interface LDKAccess {
2535 get_utxo (genesis_hash: number, short_channel_id: bigint): number;
2539 export function LDKAccess_new(impl: LDKAccess): number {
2540 if(!isWasmInitialized) {
2541 throw new Error("initializeWasm() must be awaited first!");
2543 var new_obj_idx = js_objs.length;
2544 for (var i = 0; i < js_objs.length; i++) {
2545 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2547 js_objs[i] = new WeakRef(impl);
2548 return wasm.TS_LDKAccess_new(i);
2550 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
2552 export function Access_get_utxo(this_arg: number, genesis_hash: number, short_channel_id: bigint): number {
2553 if(!isWasmInitialized) {
2554 throw new Error("initializeWasm() must be awaited first!");
2556 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
2557 return nativeResponseValue;
2560 export class LDKCOption_AccessZ {
2561 protected constructor() {}
2564 export function LDKCOption_AccessZ_ty_from_ptr(ptr: number): number {
2565 if(!isWasmInitialized) {
2566 throw new Error("initializeWasm() must be awaited first!");
2568 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
2569 return nativeResponseValue;
2572 export function LDKCOption_AccessZ_Some_get_some(ptr: number): number {
2573 if(!isWasmInitialized) {
2574 throw new Error("initializeWasm() must be awaited first!");
2576 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
2577 return nativeResponseValue;
2579 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2581 export function CResult_boolLightningErrorZ_get_ok(owner: number): boolean {
2582 if(!isWasmInitialized) {
2583 throw new Error("initializeWasm() must be awaited first!");
2585 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
2586 return nativeResponseValue;
2588 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2590 export function CResult_boolLightningErrorZ_get_err(owner: number): number {
2591 if(!isWasmInitialized) {
2592 throw new Error("initializeWasm() must be awaited first!");
2594 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
2595 return nativeResponseValue;
2597 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2599 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: number): number {
2600 if(!isWasmInitialized) {
2601 throw new Error("initializeWasm() must be awaited first!");
2603 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
2604 return nativeResponseValue;
2606 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2608 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: number): number {
2609 if(!isWasmInitialized) {
2610 throw new Error("initializeWasm() must be awaited first!");
2612 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
2613 return nativeResponseValue;
2615 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2617 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: number): number {
2618 if(!isWasmInitialized) {
2619 throw new Error("initializeWasm() must be awaited first!");
2621 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
2622 return nativeResponseValue;
2624 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2626 export function CResult_NoneLightningErrorZ_get_ok(owner: number): void {
2627 if(!isWasmInitialized) {
2628 throw new Error("initializeWasm() must be awaited first!");
2630 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
2631 // debug statements here
2633 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2635 export function CResult_NoneLightningErrorZ_get_err(owner: number): number {
2636 if(!isWasmInitialized) {
2637 throw new Error("initializeWasm() must be awaited first!");
2639 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
2640 return nativeResponseValue;
2642 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2644 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: number): number {
2645 if(!isWasmInitialized) {
2646 throw new Error("initializeWasm() must be awaited first!");
2648 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
2649 return nativeResponseValue;
2651 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2653 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: number): number {
2654 if(!isWasmInitialized) {
2655 throw new Error("initializeWasm() must be awaited first!");
2657 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
2658 return nativeResponseValue;
2660 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2662 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: number): number {
2663 if(!isWasmInitialized) {
2664 throw new Error("initializeWasm() must be awaited first!");
2666 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
2667 return nativeResponseValue;
2669 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2671 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: number): number {
2672 if(!isWasmInitialized) {
2673 throw new Error("initializeWasm() must be awaited first!");
2675 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
2676 return nativeResponseValue;
2678 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2680 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: number): number {
2681 if(!isWasmInitialized) {
2682 throw new Error("initializeWasm() must be awaited first!");
2684 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
2685 return nativeResponseValue;
2687 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2689 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: number): number {
2690 if(!isWasmInitialized) {
2691 throw new Error("initializeWasm() must be awaited first!");
2693 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
2694 return nativeResponseValue;
2697 export class LDKNetAddress {
2698 protected constructor() {}
2701 export function LDKNetAddress_ty_from_ptr(ptr: number): number {
2702 if(!isWasmInitialized) {
2703 throw new Error("initializeWasm() must be awaited first!");
2705 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
2706 return nativeResponseValue;
2709 export function LDKNetAddress_IPv4_get_addr(ptr: number): number {
2710 if(!isWasmInitialized) {
2711 throw new Error("initializeWasm() must be awaited first!");
2713 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
2714 return nativeResponseValue;
2717 export function LDKNetAddress_IPv4_get_port(ptr: number): number {
2718 if(!isWasmInitialized) {
2719 throw new Error("initializeWasm() must be awaited first!");
2721 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
2722 return nativeResponseValue;
2725 export function LDKNetAddress_IPv6_get_addr(ptr: number): number {
2726 if(!isWasmInitialized) {
2727 throw new Error("initializeWasm() must be awaited first!");
2729 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
2730 return nativeResponseValue;
2733 export function LDKNetAddress_IPv6_get_port(ptr: number): number {
2734 if(!isWasmInitialized) {
2735 throw new Error("initializeWasm() must be awaited first!");
2737 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
2738 return nativeResponseValue;
2741 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: number): number {
2742 if(!isWasmInitialized) {
2743 throw new Error("initializeWasm() must be awaited first!");
2745 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
2746 return nativeResponseValue;
2749 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: number): number {
2750 if(!isWasmInitialized) {
2751 throw new Error("initializeWasm() must be awaited first!");
2753 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
2754 return nativeResponseValue;
2757 export function LDKNetAddress_OnionV3_get_checksum(ptr: number): number {
2758 if(!isWasmInitialized) {
2759 throw new Error("initializeWasm() must be awaited first!");
2761 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
2762 return nativeResponseValue;
2765 export function LDKNetAddress_OnionV3_get_version(ptr: number): number {
2766 if(!isWasmInitialized) {
2767 throw new Error("initializeWasm() must be awaited first!");
2769 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
2770 return nativeResponseValue;
2773 export function LDKNetAddress_OnionV3_get_port(ptr: number): number {
2774 if(!isWasmInitialized) {
2775 throw new Error("initializeWasm() must be awaited first!");
2777 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
2778 return nativeResponseValue;
2780 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2782 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: number): number {
2783 if(!isWasmInitialized) {
2784 throw new Error("initializeWasm() must be awaited first!");
2786 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
2787 return nativeResponseValue;
2789 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2791 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: number): number {
2792 if(!isWasmInitialized) {
2793 throw new Error("initializeWasm() must be awaited first!");
2795 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
2796 return nativeResponseValue;
2798 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
2800 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: number): number {
2801 if(!isWasmInitialized) {
2802 throw new Error("initializeWasm() must be awaited first!");
2804 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
2805 return nativeResponseValue;
2807 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
2809 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: number): number {
2810 if(!isWasmInitialized) {
2811 throw new Error("initializeWasm() must be awaited first!");
2813 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
2814 return nativeResponseValue;
2816 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2818 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: number): number {
2819 if(!isWasmInitialized) {
2820 throw new Error("initializeWasm() must be awaited first!");
2822 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
2823 return nativeResponseValue;
2825 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2827 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: number): number {
2828 if(!isWasmInitialized) {
2829 throw new Error("initializeWasm() must be awaited first!");
2831 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
2832 return nativeResponseValue;
2834 // struct LDKNetworkGraph *CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
2836 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: number): number {
2837 if(!isWasmInitialized) {
2838 throw new Error("initializeWasm() must be awaited first!");
2840 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
2841 return nativeResponseValue;
2843 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
2845 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: number): number {
2846 if(!isWasmInitialized) {
2847 throw new Error("initializeWasm() must be awaited first!");
2849 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
2850 return nativeResponseValue;
2853 export class LDKCOption_CVec_NetAddressZZ {
2854 protected constructor() {}
2857 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: number): number {
2858 if(!isWasmInitialized) {
2859 throw new Error("initializeWasm() must be awaited first!");
2861 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
2862 return nativeResponseValue;
2865 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: number): number {
2866 if(!isWasmInitialized) {
2867 throw new Error("initializeWasm() must be awaited first!");
2869 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
2870 return nativeResponseValue;
2872 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2874 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2875 if(!isWasmInitialized) {
2876 throw new Error("initializeWasm() must be awaited first!");
2878 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2879 return nativeResponseValue;
2881 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2883 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2884 if(!isWasmInitialized) {
2885 throw new Error("initializeWasm() must be awaited first!");
2887 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2888 return nativeResponseValue;
2890 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2892 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2893 if(!isWasmInitialized) {
2894 throw new Error("initializeWasm() must be awaited first!");
2896 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2897 return nativeResponseValue;
2899 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2901 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2902 if(!isWasmInitialized) {
2903 throw new Error("initializeWasm() must be awaited first!");
2905 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2906 return nativeResponseValue;
2908 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2910 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2911 if(!isWasmInitialized) {
2912 throw new Error("initializeWasm() must be awaited first!");
2914 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
2915 return nativeResponseValue;
2917 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2919 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2920 if(!isWasmInitialized) {
2921 throw new Error("initializeWasm() must be awaited first!");
2923 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
2924 return nativeResponseValue;
2926 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2928 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: number): number {
2929 if(!isWasmInitialized) {
2930 throw new Error("initializeWasm() must be awaited first!");
2932 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
2933 return nativeResponseValue;
2935 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2937 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: number): number {
2938 if(!isWasmInitialized) {
2939 throw new Error("initializeWasm() must be awaited first!");
2941 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
2942 return nativeResponseValue;
2944 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2946 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: number): number {
2947 if(!isWasmInitialized) {
2948 throw new Error("initializeWasm() must be awaited first!");
2950 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
2951 return nativeResponseValue;
2953 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2955 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: number): void {
2956 if(!isWasmInitialized) {
2957 throw new Error("initializeWasm() must be awaited first!");
2959 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
2960 // debug statements here
2962 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2964 export function CResult_SignatureNoneZ_get_ok(owner: number): number {
2965 if(!isWasmInitialized) {
2966 throw new Error("initializeWasm() must be awaited first!");
2968 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
2969 return nativeResponseValue;
2971 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2973 export function CResult_SignatureNoneZ_get_err(owner: number): void {
2974 if(!isWasmInitialized) {
2975 throw new Error("initializeWasm() must be awaited first!");
2977 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
2978 // debug statements here
2980 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2982 export function C2Tuple_SignatureSignatureZ_get_a(owner: number): number {
2983 if(!isWasmInitialized) {
2984 throw new Error("initializeWasm() must be awaited first!");
2986 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
2987 return nativeResponseValue;
2989 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2991 export function C2Tuple_SignatureSignatureZ_get_b(owner: number): number {
2992 if(!isWasmInitialized) {
2993 throw new Error("initializeWasm() must be awaited first!");
2995 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
2996 return nativeResponseValue;
2998 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3000 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: number): number {
3001 if(!isWasmInitialized) {
3002 throw new Error("initializeWasm() must be awaited first!");
3004 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
3005 return nativeResponseValue;
3007 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3009 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: number): void {
3010 if(!isWasmInitialized) {
3011 throw new Error("initializeWasm() must be awaited first!");
3013 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
3014 // debug statements here
3016 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3018 export function CResult_SecretKeyNoneZ_get_ok(owner: number): number {
3019 if(!isWasmInitialized) {
3020 throw new Error("initializeWasm() must be awaited first!");
3022 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
3023 return nativeResponseValue;
3025 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3027 export function CResult_SecretKeyNoneZ_get_err(owner: number): void {
3028 if(!isWasmInitialized) {
3029 throw new Error("initializeWasm() must be awaited first!");
3031 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
3032 // debug statements here
3035 export interface LDKBaseSign {
3036 get_per_commitment_point (idx: bigint): number;
3037 release_commitment_secret (idx: bigint): number;
3038 validate_holder_commitment (holder_tx: number, preimages: number): number;
3039 channel_keys_id (): number;
3040 sign_counterparty_commitment (commitment_tx: number, preimages: number): number;
3041 validate_counterparty_revocation (idx: bigint, secret: number): number;
3042 sign_holder_commitment_and_htlcs (commitment_tx: number): number;
3043 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number;
3044 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number;
3045 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number;
3046 sign_closing_transaction (closing_tx: number): number;
3047 sign_channel_announcement (msg: number): number;
3048 ready_channel (channel_parameters: number): void;
3052 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: number): number {
3053 if(!isWasmInitialized) {
3054 throw new Error("initializeWasm() must be awaited first!");
3056 var new_obj_idx = js_objs.length;
3057 for (var i = 0; i < js_objs.length; i++) {
3058 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3060 js_objs[i] = new WeakRef(impl);
3061 return wasm.TS_LDKBaseSign_new(i);
3063 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3065 export function BaseSign_get_per_commitment_point(this_arg: number, idx: bigint): number {
3066 if(!isWasmInitialized) {
3067 throw new Error("initializeWasm() must be awaited first!");
3069 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
3070 return nativeResponseValue;
3072 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3074 export function BaseSign_release_commitment_secret(this_arg: number, idx: bigint): number {
3075 if(!isWasmInitialized) {
3076 throw new Error("initializeWasm() must be awaited first!");
3078 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
3079 return nativeResponseValue;
3081 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
3083 export function BaseSign_validate_holder_commitment(this_arg: number, holder_tx: number, preimages: number): number {
3084 if(!isWasmInitialized) {
3085 throw new Error("initializeWasm() must be awaited first!");
3087 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
3088 return nativeResponseValue;
3090 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
3092 export function BaseSign_channel_keys_id(this_arg: number): number {
3093 if(!isWasmInitialized) {
3094 throw new Error("initializeWasm() must be awaited first!");
3096 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
3097 return nativeResponseValue;
3099 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
3101 export function BaseSign_sign_counterparty_commitment(this_arg: number, commitment_tx: number, preimages: number): number {
3102 if(!isWasmInitialized) {
3103 throw new Error("initializeWasm() must be awaited first!");
3105 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
3106 return nativeResponseValue;
3108 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
3110 export function BaseSign_validate_counterparty_revocation(this_arg: number, idx: bigint, secret: number): number {
3111 if(!isWasmInitialized) {
3112 throw new Error("initializeWasm() must be awaited first!");
3114 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
3115 return nativeResponseValue;
3117 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
3119 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
3120 if(!isWasmInitialized) {
3121 throw new Error("initializeWasm() must be awaited first!");
3123 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
3124 return nativeResponseValue;
3126 // 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]
3128 export function BaseSign_sign_justice_revoked_output(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number {
3129 if(!isWasmInitialized) {
3130 throw new Error("initializeWasm() must be awaited first!");
3132 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
3133 return nativeResponseValue;
3135 // 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
3137 export function BaseSign_sign_justice_revoked_htlc(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number {
3138 if(!isWasmInitialized) {
3139 throw new Error("initializeWasm() must be awaited first!");
3141 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
3142 return nativeResponseValue;
3144 // 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
3146 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number {
3147 if(!isWasmInitialized) {
3148 throw new Error("initializeWasm() must be awaited first!");
3150 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
3151 return nativeResponseValue;
3153 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
3155 export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: number): number {
3156 if(!isWasmInitialized) {
3157 throw new Error("initializeWasm() must be awaited first!");
3159 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
3160 return nativeResponseValue;
3162 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
3164 export function BaseSign_sign_channel_announcement(this_arg: number, msg: number): number {
3165 if(!isWasmInitialized) {
3166 throw new Error("initializeWasm() must be awaited first!");
3168 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
3169 return nativeResponseValue;
3171 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
3173 export function BaseSign_ready_channel(this_arg: number, channel_parameters: number): void {
3174 if(!isWasmInitialized) {
3175 throw new Error("initializeWasm() must be awaited first!");
3177 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
3178 // debug statements here
3180 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
3182 export function BaseSign_get_pubkeys(this_arg: number): number {
3183 if(!isWasmInitialized) {
3184 throw new Error("initializeWasm() must be awaited first!");
3186 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
3187 return nativeResponseValue;
3190 export interface LDKSign {
3195 export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: number): number {
3196 if(!isWasmInitialized) {
3197 throw new Error("initializeWasm() must be awaited first!");
3199 var new_obj_idx = js_objs.length;
3200 for (var i = 0; i < js_objs.length; i++) {
3201 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3203 js_objs[i] = new WeakRef(impl);
3204 return wasm.TS_LDKSign_new(i);
3206 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
3208 export function Sign_write(this_arg: number): number {
3209 if(!isWasmInitialized) {
3210 throw new Error("initializeWasm() must be awaited first!");
3212 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
3213 return nativeResponseValue;
3215 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3217 export function CResult_SignDecodeErrorZ_get_ok(owner: number): number {
3218 if(!isWasmInitialized) {
3219 throw new Error("initializeWasm() must be awaited first!");
3221 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
3222 return nativeResponseValue;
3224 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3226 export function CResult_SignDecodeErrorZ_get_err(owner: number): number {
3227 if(!isWasmInitialized) {
3228 throw new Error("initializeWasm() must be awaited first!");
3230 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
3231 return nativeResponseValue;
3233 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3235 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: number): number {
3236 if(!isWasmInitialized) {
3237 throw new Error("initializeWasm() must be awaited first!");
3239 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3240 return nativeResponseValue;
3242 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3244 export function CResult_RecoverableSignatureNoneZ_get_err(owner: number): void {
3245 if(!isWasmInitialized) {
3246 throw new Error("initializeWasm() must be awaited first!");
3248 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3249 // debug statements here
3251 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3253 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: number): number {
3254 if(!isWasmInitialized) {
3255 throw new Error("initializeWasm() must be awaited first!");
3257 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
3258 return nativeResponseValue;
3260 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3262 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: number): void {
3263 if(!isWasmInitialized) {
3264 throw new Error("initializeWasm() must be awaited first!");
3266 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
3267 // debug statements here
3269 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3271 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: number): number {
3272 if(!isWasmInitialized) {
3273 throw new Error("initializeWasm() must be awaited first!");
3275 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
3276 return nativeResponseValue;
3278 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3280 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: number): number {
3281 if(!isWasmInitialized) {
3282 throw new Error("initializeWasm() must be awaited first!");
3284 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
3285 return nativeResponseValue;
3287 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3289 export function CResult_TransactionNoneZ_get_ok(owner: number): number {
3290 if(!isWasmInitialized) {
3291 throw new Error("initializeWasm() must be awaited first!");
3293 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
3294 return nativeResponseValue;
3296 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3298 export function CResult_TransactionNoneZ_get_err(owner: number): void {
3299 if(!isWasmInitialized) {
3300 throw new Error("initializeWasm() must be awaited first!");
3302 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
3303 // debug statements here
3306 export class LDKCOption_u16Z {
3307 protected constructor() {}
3310 export function LDKCOption_u16Z_ty_from_ptr(ptr: number): number {
3311 if(!isWasmInitialized) {
3312 throw new Error("initializeWasm() must be awaited first!");
3314 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
3315 return nativeResponseValue;
3318 export function LDKCOption_u16Z_Some_get_some(ptr: number): number {
3319 if(!isWasmInitialized) {
3320 throw new Error("initializeWasm() must be awaited first!");
3322 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
3323 return nativeResponseValue;
3326 export class LDKAPIError {
3327 protected constructor() {}
3330 export function LDKAPIError_ty_from_ptr(ptr: number): number {
3331 if(!isWasmInitialized) {
3332 throw new Error("initializeWasm() must be awaited first!");
3334 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
3335 return nativeResponseValue;
3338 export function LDKAPIError_APIMisuseError_get_err(ptr: number): number {
3339 if(!isWasmInitialized) {
3340 throw new Error("initializeWasm() must be awaited first!");
3342 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
3343 return nativeResponseValue;
3346 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: number): number {
3347 if(!isWasmInitialized) {
3348 throw new Error("initializeWasm() must be awaited first!");
3350 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
3351 return nativeResponseValue;
3354 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: number): number {
3355 if(!isWasmInitialized) {
3356 throw new Error("initializeWasm() must be awaited first!");
3358 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
3359 return nativeResponseValue;
3362 export function LDKAPIError_RouteError_get_err(ptr: number): number {
3363 if(!isWasmInitialized) {
3364 throw new Error("initializeWasm() must be awaited first!");
3366 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
3367 return nativeResponseValue;
3370 export function LDKAPIError_ChannelUnavailable_get_err(ptr: number): number {
3371 if(!isWasmInitialized) {
3372 throw new Error("initializeWasm() must be awaited first!");
3374 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
3375 return nativeResponseValue;
3378 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: number): number {
3379 if(!isWasmInitialized) {
3380 throw new Error("initializeWasm() must be awaited first!");
3382 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
3383 return nativeResponseValue;
3385 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3387 export function CResult_NoneAPIErrorZ_get_ok(owner: number): void {
3388 if(!isWasmInitialized) {
3389 throw new Error("initializeWasm() must be awaited first!");
3391 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
3392 // debug statements here
3394 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3396 export function CResult_NoneAPIErrorZ_get_err(owner: number): number {
3397 if(!isWasmInitialized) {
3398 throw new Error("initializeWasm() must be awaited first!");
3400 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
3401 return nativeResponseValue;
3403 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3405 export function CResult__u832APIErrorZ_get_ok(owner: number): number {
3406 if(!isWasmInitialized) {
3407 throw new Error("initializeWasm() must be awaited first!");
3409 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
3410 return nativeResponseValue;
3412 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3414 export function CResult__u832APIErrorZ_get_err(owner: number): number {
3415 if(!isWasmInitialized) {
3416 throw new Error("initializeWasm() must be awaited first!");
3418 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
3419 return nativeResponseValue;
3422 export class LDKPaymentSendFailure {
3423 protected constructor() {}
3426 export function LDKPaymentSendFailure_ty_from_ptr(ptr: number): number {
3427 if(!isWasmInitialized) {
3428 throw new Error("initializeWasm() must be awaited first!");
3430 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
3431 return nativeResponseValue;
3434 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: number): number {
3435 if(!isWasmInitialized) {
3436 throw new Error("initializeWasm() must be awaited first!");
3438 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
3439 return nativeResponseValue;
3442 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: number): number {
3443 if(!isWasmInitialized) {
3444 throw new Error("initializeWasm() must be awaited first!");
3446 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
3447 return nativeResponseValue;
3450 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: number): number {
3451 if(!isWasmInitialized) {
3452 throw new Error("initializeWasm() must be awaited first!");
3454 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
3455 return nativeResponseValue;
3458 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: number): number {
3459 if(!isWasmInitialized) {
3460 throw new Error("initializeWasm() must be awaited first!");
3462 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
3463 return nativeResponseValue;
3466 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: number): number {
3467 if(!isWasmInitialized) {
3468 throw new Error("initializeWasm() must be awaited first!");
3470 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
3471 return nativeResponseValue;
3474 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: number): number {
3475 if(!isWasmInitialized) {
3476 throw new Error("initializeWasm() must be awaited first!");
3478 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
3479 return nativeResponseValue;
3481 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3483 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: number): number {
3484 if(!isWasmInitialized) {
3485 throw new Error("initializeWasm() must be awaited first!");
3487 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
3488 return nativeResponseValue;
3490 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3492 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: number): number {
3493 if(!isWasmInitialized) {
3494 throw new Error("initializeWasm() must be awaited first!");
3496 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
3497 return nativeResponseValue;
3499 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3501 export function CResult_NonePaymentSendFailureZ_get_ok(owner: number): void {
3502 if(!isWasmInitialized) {
3503 throw new Error("initializeWasm() must be awaited first!");
3505 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
3506 // debug statements here
3508 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3510 export function CResult_NonePaymentSendFailureZ_get_err(owner: number): number {
3511 if(!isWasmInitialized) {
3512 throw new Error("initializeWasm() must be awaited first!");
3514 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
3515 return nativeResponseValue;
3517 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3519 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: number): number {
3520 if(!isWasmInitialized) {
3521 throw new Error("initializeWasm() must be awaited first!");
3523 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
3524 return nativeResponseValue;
3526 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3528 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: number): number {
3529 if(!isWasmInitialized) {
3530 throw new Error("initializeWasm() must be awaited first!");
3532 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
3533 return nativeResponseValue;
3535 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3537 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: number): number {
3538 if(!isWasmInitialized) {
3539 throw new Error("initializeWasm() must be awaited first!");
3541 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
3542 return nativeResponseValue;
3544 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3546 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: number): number {
3547 if(!isWasmInitialized) {
3548 throw new Error("initializeWasm() must be awaited first!");
3550 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
3551 return nativeResponseValue;
3553 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3555 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: number): number {
3556 if(!isWasmInitialized) {
3557 throw new Error("initializeWasm() must be awaited first!");
3559 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
3560 return nativeResponseValue;
3562 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3564 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: number): number {
3565 if(!isWasmInitialized) {
3566 throw new Error("initializeWasm() must be awaited first!");
3568 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
3569 return nativeResponseValue;
3571 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3573 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: number): number {
3574 if(!isWasmInitialized) {
3575 throw new Error("initializeWasm() must be awaited first!");
3577 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
3578 return nativeResponseValue;
3580 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3582 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: number): void {
3583 if(!isWasmInitialized) {
3584 throw new Error("initializeWasm() must be awaited first!");
3586 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
3587 // debug statements here
3589 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3591 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: number): number {
3592 if(!isWasmInitialized) {
3593 throw new Error("initializeWasm() must be awaited first!");
3595 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
3596 return nativeResponseValue;
3598 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3600 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: number): number {
3601 if(!isWasmInitialized) {
3602 throw new Error("initializeWasm() must be awaited first!");
3604 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
3605 return nativeResponseValue;
3607 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3609 export function CResult_PaymentSecretNoneZ_get_ok(owner: number): number {
3610 if(!isWasmInitialized) {
3611 throw new Error("initializeWasm() must be awaited first!");
3613 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
3614 return nativeResponseValue;
3616 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3618 export function CResult_PaymentSecretNoneZ_get_err(owner: number): void {
3619 if(!isWasmInitialized) {
3620 throw new Error("initializeWasm() must be awaited first!");
3622 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
3623 // debug statements here
3625 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3627 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: number): number {
3628 if(!isWasmInitialized) {
3629 throw new Error("initializeWasm() must be awaited first!");
3631 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
3632 return nativeResponseValue;
3634 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3636 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: number): number {
3637 if(!isWasmInitialized) {
3638 throw new Error("initializeWasm() must be awaited first!");
3640 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
3641 return nativeResponseValue;
3643 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3645 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: number): number {
3646 if(!isWasmInitialized) {
3647 throw new Error("initializeWasm() must be awaited first!");
3649 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
3650 return nativeResponseValue;
3652 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3654 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: number): number {
3655 if(!isWasmInitialized) {
3656 throw new Error("initializeWasm() must be awaited first!");
3658 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
3659 return nativeResponseValue;
3661 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3663 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: number): number {
3664 if(!isWasmInitialized) {
3665 throw new Error("initializeWasm() must be awaited first!");
3667 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
3668 return nativeResponseValue;
3670 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3672 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: number): number {
3673 if(!isWasmInitialized) {
3674 throw new Error("initializeWasm() must be awaited first!");
3676 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
3677 return nativeResponseValue;
3679 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3681 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: number): number {
3682 if(!isWasmInitialized) {
3683 throw new Error("initializeWasm() must be awaited first!");
3685 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
3686 return nativeResponseValue;
3688 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3690 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: number): number {
3691 if(!isWasmInitialized) {
3692 throw new Error("initializeWasm() must be awaited first!");
3694 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
3695 return nativeResponseValue;
3697 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3699 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: number): number {
3700 if(!isWasmInitialized) {
3701 throw new Error("initializeWasm() must be awaited first!");
3703 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
3704 return nativeResponseValue;
3706 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3708 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: number): number {
3709 if(!isWasmInitialized) {
3710 throw new Error("initializeWasm() must be awaited first!");
3712 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
3713 return nativeResponseValue;
3715 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3717 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: number): number {
3718 if(!isWasmInitialized) {
3719 throw new Error("initializeWasm() must be awaited first!");
3721 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
3722 return nativeResponseValue;
3724 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3726 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: number): number {
3727 if(!isWasmInitialized) {
3728 throw new Error("initializeWasm() must be awaited first!");
3730 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
3731 return nativeResponseValue;
3734 export interface LDKWatch {
3735 watch_channel (funding_txo: number, monitor: number): number;
3736 update_channel (funding_txo: number, update: number): number;
3737 release_pending_monitor_events (): number;
3741 export function LDKWatch_new(impl: LDKWatch): number {
3742 if(!isWasmInitialized) {
3743 throw new Error("initializeWasm() must be awaited first!");
3745 var new_obj_idx = js_objs.length;
3746 for (var i = 0; i < js_objs.length; i++) {
3747 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3749 js_objs[i] = new WeakRef(impl);
3750 return wasm.TS_LDKWatch_new(i);
3752 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
3754 export function Watch_watch_channel(this_arg: number, funding_txo: number, monitor: number): number {
3755 if(!isWasmInitialized) {
3756 throw new Error("initializeWasm() must be awaited first!");
3758 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
3759 return nativeResponseValue;
3761 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
3763 export function Watch_update_channel(this_arg: number, funding_txo: number, update: number): number {
3764 if(!isWasmInitialized) {
3765 throw new Error("initializeWasm() must be awaited first!");
3767 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
3768 return nativeResponseValue;
3770 // LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
3772 export function Watch_release_pending_monitor_events(this_arg: number): number {
3773 if(!isWasmInitialized) {
3774 throw new Error("initializeWasm() must be awaited first!");
3776 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
3777 return nativeResponseValue;
3780 export interface LDKBroadcasterInterface {
3781 broadcast_transaction (tx: number): void;
3785 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): number {
3786 if(!isWasmInitialized) {
3787 throw new Error("initializeWasm() must be awaited first!");
3789 var new_obj_idx = js_objs.length;
3790 for (var i = 0; i < js_objs.length; i++) {
3791 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3793 js_objs[i] = new WeakRef(impl);
3794 return wasm.TS_LDKBroadcasterInterface_new(i);
3796 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
3798 export function BroadcasterInterface_broadcast_transaction(this_arg: number, tx: number): void {
3799 if(!isWasmInitialized) {
3800 throw new Error("initializeWasm() must be awaited first!");
3802 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
3803 // debug statements here
3806 export interface LDKKeysInterface {
3807 get_node_secret (recipient: Recipient): number;
3808 get_destination_script (): number;
3809 get_shutdown_scriptpubkey (): number;
3810 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): number;
3811 get_secure_random_bytes (): number;
3812 read_chan_signer (reader: number): number;
3813 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): number;
3814 get_inbound_payment_key_material (): number;
3818 export function LDKKeysInterface_new(impl: LDKKeysInterface): number {
3819 if(!isWasmInitialized) {
3820 throw new Error("initializeWasm() must be awaited first!");
3822 var new_obj_idx = js_objs.length;
3823 for (var i = 0; i < js_objs.length; i++) {
3824 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3826 js_objs[i] = new WeakRef(impl);
3827 return wasm.TS_LDKKeysInterface_new(i);
3829 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
3831 export function KeysInterface_get_node_secret(this_arg: number, recipient: Recipient): number {
3832 if(!isWasmInitialized) {
3833 throw new Error("initializeWasm() must be awaited first!");
3835 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
3836 return nativeResponseValue;
3838 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
3840 export function KeysInterface_get_destination_script(this_arg: number): number {
3841 if(!isWasmInitialized) {
3842 throw new Error("initializeWasm() must be awaited first!");
3844 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
3845 return nativeResponseValue;
3847 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
3849 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: number): number {
3850 if(!isWasmInitialized) {
3851 throw new Error("initializeWasm() must be awaited first!");
3853 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
3854 return nativeResponseValue;
3856 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
3858 export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: bigint): number {
3859 if(!isWasmInitialized) {
3860 throw new Error("initializeWasm() must be awaited first!");
3862 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
3863 return nativeResponseValue;
3865 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
3867 export function KeysInterface_get_secure_random_bytes(this_arg: number): number {
3868 if(!isWasmInitialized) {
3869 throw new Error("initializeWasm() must be awaited first!");
3871 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
3872 return nativeResponseValue;
3874 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
3876 export function KeysInterface_read_chan_signer(this_arg: number, reader: number): number {
3877 if(!isWasmInitialized) {
3878 throw new Error("initializeWasm() must be awaited first!");
3880 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
3881 return nativeResponseValue;
3883 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient
3885 export function KeysInterface_sign_invoice(this_arg: number, hrp_bytes: number, invoice_data: number, receipient: Recipient): number {
3886 if(!isWasmInitialized) {
3887 throw new Error("initializeWasm() must be awaited first!");
3889 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
3890 return nativeResponseValue;
3892 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
3894 export function KeysInterface_get_inbound_payment_key_material(this_arg: number): number {
3895 if(!isWasmInitialized) {
3896 throw new Error("initializeWasm() must be awaited first!");
3898 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
3899 return nativeResponseValue;
3902 export interface LDKFeeEstimator {
3903 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
3907 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
3908 if(!isWasmInitialized) {
3909 throw new Error("initializeWasm() must be awaited first!");
3911 var new_obj_idx = js_objs.length;
3912 for (var i = 0; i < js_objs.length; i++) {
3913 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3915 js_objs[i] = new WeakRef(impl);
3916 return wasm.TS_LDKFeeEstimator_new(i);
3918 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
3920 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: ConfirmationTarget): number {
3921 if(!isWasmInitialized) {
3922 throw new Error("initializeWasm() must be awaited first!");
3924 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
3925 return nativeResponseValue;
3927 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3929 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: number): number {
3930 if(!isWasmInitialized) {
3931 throw new Error("initializeWasm() must be awaited first!");
3933 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
3934 return nativeResponseValue;
3936 // struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3938 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: number): number {
3939 if(!isWasmInitialized) {
3940 throw new Error("initializeWasm() must be awaited first!");
3942 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
3943 return nativeResponseValue;
3945 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3947 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: number): number {
3948 if(!isWasmInitialized) {
3949 throw new Error("initializeWasm() must be awaited first!");
3951 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
3952 return nativeResponseValue;
3954 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3956 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: number): number {
3957 if(!isWasmInitialized) {
3958 throw new Error("initializeWasm() must be awaited first!");
3960 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
3961 return nativeResponseValue;
3963 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3965 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: number): number {
3966 if(!isWasmInitialized) {
3967 throw new Error("initializeWasm() must be awaited first!");
3969 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
3970 return nativeResponseValue;
3972 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3974 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: number): number {
3975 if(!isWasmInitialized) {
3976 throw new Error("initializeWasm() must be awaited first!");
3978 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
3979 return nativeResponseValue;
3981 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3983 export function CResult_OutPointDecodeErrorZ_get_ok(owner: number): number {
3984 if(!isWasmInitialized) {
3985 throw new Error("initializeWasm() must be awaited first!");
3987 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
3988 return nativeResponseValue;
3990 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3992 export function CResult_OutPointDecodeErrorZ_get_err(owner: number): number {
3993 if(!isWasmInitialized) {
3994 throw new Error("initializeWasm() must be awaited first!");
3996 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
3997 return nativeResponseValue;
4000 export interface LDKType {
4002 debug_str (): number;
4007 export function LDKType_new(impl: LDKType): number {
4008 if(!isWasmInitialized) {
4009 throw new Error("initializeWasm() must be awaited first!");
4011 var new_obj_idx = js_objs.length;
4012 for (var i = 0; i < js_objs.length; i++) {
4013 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4015 js_objs[i] = new WeakRef(impl);
4016 return wasm.TS_LDKType_new(i);
4018 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
4020 export function Type_type_id(this_arg: number): number {
4021 if(!isWasmInitialized) {
4022 throw new Error("initializeWasm() must be awaited first!");
4024 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
4025 return nativeResponseValue;
4027 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
4029 export function Type_debug_str(this_arg: number): number {
4030 if(!isWasmInitialized) {
4031 throw new Error("initializeWasm() must be awaited first!");
4033 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
4034 return nativeResponseValue;
4036 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
4038 export function Type_write(this_arg: number): number {
4039 if(!isWasmInitialized) {
4040 throw new Error("initializeWasm() must be awaited first!");
4042 const nativeResponseValue = wasm.TS_Type_write(this_arg);
4043 return nativeResponseValue;
4046 export class LDKCOption_TypeZ {
4047 protected constructor() {}
4050 export function LDKCOption_TypeZ_ty_from_ptr(ptr: number): number {
4051 if(!isWasmInitialized) {
4052 throw new Error("initializeWasm() must be awaited first!");
4054 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
4055 return nativeResponseValue;
4058 export function LDKCOption_TypeZ_Some_get_some(ptr: number): number {
4059 if(!isWasmInitialized) {
4060 throw new Error("initializeWasm() must be awaited first!");
4062 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
4063 return nativeResponseValue;
4065 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4067 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: number): number {
4068 if(!isWasmInitialized) {
4069 throw new Error("initializeWasm() must be awaited first!");
4071 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
4072 return nativeResponseValue;
4074 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4076 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: number): number {
4077 if(!isWasmInitialized) {
4078 throw new Error("initializeWasm() must be awaited first!");
4080 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
4081 return nativeResponseValue;
4084 export class LDKPaymentError {
4085 protected constructor() {}
4088 export function LDKPaymentError_ty_from_ptr(ptr: number): number {
4089 if(!isWasmInitialized) {
4090 throw new Error("initializeWasm() must be awaited first!");
4092 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
4093 return nativeResponseValue;
4096 export function LDKPaymentError_Invoice_get_invoice(ptr: number): number {
4097 if(!isWasmInitialized) {
4098 throw new Error("initializeWasm() must be awaited first!");
4100 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
4101 return nativeResponseValue;
4104 export function LDKPaymentError_Routing_get_routing(ptr: number): number {
4105 if(!isWasmInitialized) {
4106 throw new Error("initializeWasm() must be awaited first!");
4108 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
4109 return nativeResponseValue;
4112 export function LDKPaymentError_Sending_get_sending(ptr: number): number {
4113 if(!isWasmInitialized) {
4114 throw new Error("initializeWasm() must be awaited first!");
4116 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
4117 return nativeResponseValue;
4119 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4121 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: number): number {
4122 if(!isWasmInitialized) {
4123 throw new Error("initializeWasm() must be awaited first!");
4125 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
4126 return nativeResponseValue;
4128 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4130 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: number): number {
4131 if(!isWasmInitialized) {
4132 throw new Error("initializeWasm() must be awaited first!");
4134 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
4135 return nativeResponseValue;
4138 export class LDKParseError {
4139 protected constructor() {}
4142 export function LDKParseError_ty_from_ptr(ptr: number): number {
4143 if(!isWasmInitialized) {
4144 throw new Error("initializeWasm() must be awaited first!");
4146 const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
4147 return nativeResponseValue;
4150 export function LDKParseError_Bech32Error_get_bech32_error(ptr: number): number {
4151 if(!isWasmInitialized) {
4152 throw new Error("initializeWasm() must be awaited first!");
4154 const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
4155 return nativeResponseValue;
4158 export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: number): number {
4159 if(!isWasmInitialized) {
4160 throw new Error("initializeWasm() must be awaited first!");
4162 const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
4163 return nativeResponseValue;
4166 export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: number): Secp256k1Error {
4167 if(!isWasmInitialized) {
4168 throw new Error("initializeWasm() must be awaited first!");
4170 const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
4171 return nativeResponseValue;
4174 export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: number): number {
4175 if(!isWasmInitialized) {
4176 throw new Error("initializeWasm() must be awaited first!");
4178 const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
4179 return nativeResponseValue;
4182 export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: number): number {
4183 if(!isWasmInitialized) {
4184 throw new Error("initializeWasm() must be awaited first!");
4186 const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
4187 return nativeResponseValue;
4189 // enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4191 export function CResult_SiPrefixParseErrorZ_get_ok(owner: number): SiPrefix {
4192 if(!isWasmInitialized) {
4193 throw new Error("initializeWasm() must be awaited first!");
4195 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
4196 return nativeResponseValue;
4198 // struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4200 export function CResult_SiPrefixParseErrorZ_get_err(owner: number): number {
4201 if(!isWasmInitialized) {
4202 throw new Error("initializeWasm() must be awaited first!");
4204 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
4205 return nativeResponseValue;
4208 export class LDKParseOrSemanticError {
4209 protected constructor() {}
4212 export function LDKParseOrSemanticError_ty_from_ptr(ptr: number): number {
4213 if(!isWasmInitialized) {
4214 throw new Error("initializeWasm() must be awaited first!");
4216 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
4217 return nativeResponseValue;
4220 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: number): number {
4221 if(!isWasmInitialized) {
4222 throw new Error("initializeWasm() must be awaited first!");
4224 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
4225 return nativeResponseValue;
4228 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: number): SemanticError {
4229 if(!isWasmInitialized) {
4230 throw new Error("initializeWasm() must be awaited first!");
4232 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
4233 return nativeResponseValue;
4235 // struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4237 export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: number): number {
4238 if(!isWasmInitialized) {
4239 throw new Error("initializeWasm() must be awaited first!");
4241 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
4242 return nativeResponseValue;
4244 // struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4246 export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: number): number {
4247 if(!isWasmInitialized) {
4248 throw new Error("initializeWasm() must be awaited first!");
4250 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
4251 return nativeResponseValue;
4253 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4255 export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: number): number {
4256 if(!isWasmInitialized) {
4257 throw new Error("initializeWasm() must be awaited first!");
4259 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
4260 return nativeResponseValue;
4262 // struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4264 export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: number): number {
4265 if(!isWasmInitialized) {
4266 throw new Error("initializeWasm() must be awaited first!");
4268 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
4269 return nativeResponseValue;
4271 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4273 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: number): number {
4274 if(!isWasmInitialized) {
4275 throw new Error("initializeWasm() must be awaited first!");
4277 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
4278 return nativeResponseValue;
4280 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4282 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: number): number {
4283 if(!isWasmInitialized) {
4284 throw new Error("initializeWasm() must be awaited first!");
4286 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
4287 return nativeResponseValue;
4289 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4291 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: number): number {
4292 if(!isWasmInitialized) {
4293 throw new Error("initializeWasm() must be awaited first!");
4295 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
4296 return nativeResponseValue;
4298 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4300 export function CResult_PayeePubKeyErrorZ_get_ok(owner: number): number {
4301 if(!isWasmInitialized) {
4302 throw new Error("initializeWasm() must be awaited first!");
4304 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
4305 return nativeResponseValue;
4307 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4309 export function CResult_PayeePubKeyErrorZ_get_err(owner: number): Secp256k1Error {
4310 if(!isWasmInitialized) {
4311 throw new Error("initializeWasm() must be awaited first!");
4313 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
4314 return nativeResponseValue;
4316 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4318 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: number): number {
4319 if(!isWasmInitialized) {
4320 throw new Error("initializeWasm() must be awaited first!");
4322 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
4323 return nativeResponseValue;
4325 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4327 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: number): CreationError {
4328 if(!isWasmInitialized) {
4329 throw new Error("initializeWasm() must be awaited first!");
4331 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
4332 return nativeResponseValue;
4334 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4336 export function CResult_NoneSemanticErrorZ_get_ok(owner: number): void {
4337 if(!isWasmInitialized) {
4338 throw new Error("initializeWasm() must be awaited first!");
4340 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
4341 // debug statements here
4343 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4345 export function CResult_NoneSemanticErrorZ_get_err(owner: number): SemanticError {
4346 if(!isWasmInitialized) {
4347 throw new Error("initializeWasm() must be awaited first!");
4349 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
4350 return nativeResponseValue;
4352 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4354 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: number): number {
4355 if(!isWasmInitialized) {
4356 throw new Error("initializeWasm() must be awaited first!");
4358 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
4359 return nativeResponseValue;
4361 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4363 export function CResult_InvoiceSemanticErrorZ_get_err(owner: number): SemanticError {
4364 if(!isWasmInitialized) {
4365 throw new Error("initializeWasm() must be awaited first!");
4367 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
4368 return nativeResponseValue;
4370 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4372 export function CResult_DescriptionCreationErrorZ_get_ok(owner: number): number {
4373 if(!isWasmInitialized) {
4374 throw new Error("initializeWasm() must be awaited first!");
4376 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
4377 return nativeResponseValue;
4379 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4381 export function CResult_DescriptionCreationErrorZ_get_err(owner: number): CreationError {
4382 if(!isWasmInitialized) {
4383 throw new Error("initializeWasm() must be awaited first!");
4385 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
4386 return nativeResponseValue;
4388 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4390 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: number): number {
4391 if(!isWasmInitialized) {
4392 throw new Error("initializeWasm() must be awaited first!");
4394 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
4395 return nativeResponseValue;
4397 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4399 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: number): CreationError {
4400 if(!isWasmInitialized) {
4401 throw new Error("initializeWasm() must be awaited first!");
4403 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
4404 return nativeResponseValue;
4406 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4408 export function CResult_StringErrorZ_get_ok(owner: number): number {
4409 if(!isWasmInitialized) {
4410 throw new Error("initializeWasm() must be awaited first!");
4412 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
4413 return nativeResponseValue;
4415 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4417 export function CResult_StringErrorZ_get_err(owner: number): Secp256k1Error {
4418 if(!isWasmInitialized) {
4419 throw new Error("initializeWasm() must be awaited first!");
4421 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
4422 return nativeResponseValue;
4424 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4426 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: number): number {
4427 if(!isWasmInitialized) {
4428 throw new Error("initializeWasm() must be awaited first!");
4430 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
4431 return nativeResponseValue;
4433 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4435 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: number): number {
4436 if(!isWasmInitialized) {
4437 throw new Error("initializeWasm() must be awaited first!");
4439 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
4440 return nativeResponseValue;
4443 export class LDKCOption_MonitorEventZ {
4444 protected constructor() {}
4447 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: number): number {
4448 if(!isWasmInitialized) {
4449 throw new Error("initializeWasm() must be awaited first!");
4451 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
4452 return nativeResponseValue;
4455 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: number): number {
4456 if(!isWasmInitialized) {
4457 throw new Error("initializeWasm() must be awaited first!");
4459 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
4460 return nativeResponseValue;
4462 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4464 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: number): number {
4465 if(!isWasmInitialized) {
4466 throw new Error("initializeWasm() must be awaited first!");
4468 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
4469 return nativeResponseValue;
4471 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4473 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: number): number {
4474 if(!isWasmInitialized) {
4475 throw new Error("initializeWasm() must be awaited first!");
4477 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
4478 return nativeResponseValue;
4480 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4482 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: number): number {
4483 if(!isWasmInitialized) {
4484 throw new Error("initializeWasm() must be awaited first!");
4486 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
4487 return nativeResponseValue;
4489 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4491 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: number): number {
4492 if(!isWasmInitialized) {
4493 throw new Error("initializeWasm() must be awaited first!");
4495 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
4496 return nativeResponseValue;
4498 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4500 export function C2Tuple_OutPointScriptZ_get_a(owner: number): number {
4501 if(!isWasmInitialized) {
4502 throw new Error("initializeWasm() must be awaited first!");
4504 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
4505 return nativeResponseValue;
4507 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4509 export function C2Tuple_OutPointScriptZ_get_b(owner: number): number {
4510 if(!isWasmInitialized) {
4511 throw new Error("initializeWasm() must be awaited first!");
4513 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
4514 return nativeResponseValue;
4516 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4518 export function C2Tuple_u32ScriptZ_get_a(owner: number): number {
4519 if(!isWasmInitialized) {
4520 throw new Error("initializeWasm() must be awaited first!");
4522 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
4523 return nativeResponseValue;
4525 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4527 export function C2Tuple_u32ScriptZ_get_b(owner: number): number {
4528 if(!isWasmInitialized) {
4529 throw new Error("initializeWasm() must be awaited first!");
4531 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
4532 return nativeResponseValue;
4534 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4536 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: number): number {
4537 if(!isWasmInitialized) {
4538 throw new Error("initializeWasm() must be awaited first!");
4540 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
4541 return nativeResponseValue;
4543 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4545 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: number): number {
4546 if(!isWasmInitialized) {
4547 throw new Error("initializeWasm() must be awaited first!");
4549 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
4550 return nativeResponseValue;
4552 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4554 export function C2Tuple_u32TxOutZ_get_a(owner: number): number {
4555 if(!isWasmInitialized) {
4556 throw new Error("initializeWasm() must be awaited first!");
4558 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
4559 return nativeResponseValue;
4561 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4563 export function C2Tuple_u32TxOutZ_get_b(owner: number): number {
4564 if(!isWasmInitialized) {
4565 throw new Error("initializeWasm() must be awaited first!");
4567 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
4568 return nativeResponseValue;
4570 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4572 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: number): number {
4573 if(!isWasmInitialized) {
4574 throw new Error("initializeWasm() must be awaited first!");
4576 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
4577 return nativeResponseValue;
4579 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4581 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: number): number {
4582 if(!isWasmInitialized) {
4583 throw new Error("initializeWasm() must be awaited first!");
4585 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
4586 return nativeResponseValue;
4589 export class LDKBalance {
4590 protected constructor() {}
4593 export function LDKBalance_ty_from_ptr(ptr: number): number {
4594 if(!isWasmInitialized) {
4595 throw new Error("initializeWasm() must be awaited first!");
4597 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
4598 return nativeResponseValue;
4601 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: number): bigint {
4602 if(!isWasmInitialized) {
4603 throw new Error("initializeWasm() must be awaited first!");
4605 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
4606 return nativeResponseValue;
4609 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: number): bigint {
4610 if(!isWasmInitialized) {
4611 throw new Error("initializeWasm() must be awaited first!");
4613 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
4614 return nativeResponseValue;
4617 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: number): number {
4618 if(!isWasmInitialized) {
4619 throw new Error("initializeWasm() must be awaited first!");
4621 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
4622 return nativeResponseValue;
4625 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: number): bigint {
4626 if(!isWasmInitialized) {
4627 throw new Error("initializeWasm() must be awaited first!");
4629 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
4630 return nativeResponseValue;
4633 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: number): number {
4634 if(!isWasmInitialized) {
4635 throw new Error("initializeWasm() must be awaited first!");
4637 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
4638 return nativeResponseValue;
4641 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr: number): bigint {
4642 if(!isWasmInitialized) {
4643 throw new Error("initializeWasm() must be awaited first!");
4645 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr);
4646 return nativeResponseValue;
4649 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr: number): number {
4650 if(!isWasmInitialized) {
4651 throw new Error("initializeWasm() must be awaited first!");
4653 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr);
4654 return nativeResponseValue;
4656 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4658 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: number): number {
4659 if(!isWasmInitialized) {
4660 throw new Error("initializeWasm() must be awaited first!");
4662 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
4663 return nativeResponseValue;
4665 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4667 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: number): number {
4668 if(!isWasmInitialized) {
4669 throw new Error("initializeWasm() must be awaited first!");
4671 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
4672 return nativeResponseValue;
4674 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4676 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: number): number {
4677 if(!isWasmInitialized) {
4678 throw new Error("initializeWasm() must be awaited first!");
4680 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
4681 return nativeResponseValue;
4683 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4685 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: number): number {
4686 if(!isWasmInitialized) {
4687 throw new Error("initializeWasm() must be awaited first!");
4689 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
4690 return nativeResponseValue;
4692 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4694 export function C2Tuple_PublicKeyTypeZ_get_a(owner: number): number {
4695 if(!isWasmInitialized) {
4696 throw new Error("initializeWasm() must be awaited first!");
4698 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
4699 return nativeResponseValue;
4701 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4703 export function C2Tuple_PublicKeyTypeZ_get_b(owner: number): number {
4704 if(!isWasmInitialized) {
4705 throw new Error("initializeWasm() must be awaited first!");
4707 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
4708 return nativeResponseValue;
4711 export class LDKCOption_NetAddressZ {
4712 protected constructor() {}
4715 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: number): number {
4716 if(!isWasmInitialized) {
4717 throw new Error("initializeWasm() must be awaited first!");
4719 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
4720 return nativeResponseValue;
4723 export function LDKCOption_NetAddressZ_Some_get_some(ptr: number): number {
4724 if(!isWasmInitialized) {
4725 throw new Error("initializeWasm() must be awaited first!");
4727 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
4728 return nativeResponseValue;
4730 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4732 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: number): number {
4733 if(!isWasmInitialized) {
4734 throw new Error("initializeWasm() must be awaited first!");
4736 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
4737 return nativeResponseValue;
4739 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4741 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: number): number {
4742 if(!isWasmInitialized) {
4743 throw new Error("initializeWasm() must be awaited first!");
4745 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
4746 return nativeResponseValue;
4748 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4750 export function CResult_NonePeerHandleErrorZ_get_ok(owner: number): void {
4751 if(!isWasmInitialized) {
4752 throw new Error("initializeWasm() must be awaited first!");
4754 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
4755 // debug statements here
4757 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4759 export function CResult_NonePeerHandleErrorZ_get_err(owner: number): number {
4760 if(!isWasmInitialized) {
4761 throw new Error("initializeWasm() must be awaited first!");
4763 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
4764 return nativeResponseValue;
4766 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4768 export function CResult_boolPeerHandleErrorZ_get_ok(owner: number): boolean {
4769 if(!isWasmInitialized) {
4770 throw new Error("initializeWasm() must be awaited first!");
4772 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
4773 return nativeResponseValue;
4775 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4777 export function CResult_boolPeerHandleErrorZ_get_err(owner: number): number {
4778 if(!isWasmInitialized) {
4779 throw new Error("initializeWasm() must be awaited first!");
4781 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
4782 return nativeResponseValue;
4784 // void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4786 export function CResult_NoneErrorZ_get_ok(owner: number): void {
4787 if(!isWasmInitialized) {
4788 throw new Error("initializeWasm() must be awaited first!");
4790 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_ok(owner);
4791 // debug statements here
4793 // enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4795 export function CResult_NoneErrorZ_get_err(owner: number): IOError {
4796 if(!isWasmInitialized) {
4797 throw new Error("initializeWasm() must be awaited first!");
4799 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_err(owner);
4800 return nativeResponseValue;
4802 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4804 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: number): number {
4805 if(!isWasmInitialized) {
4806 throw new Error("initializeWasm() must be awaited first!");
4808 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
4809 return nativeResponseValue;
4811 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4813 export function CResult_NetAddressDecodeErrorZ_get_err(owner: number): number {
4814 if(!isWasmInitialized) {
4815 throw new Error("initializeWasm() must be awaited first!");
4817 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
4818 return nativeResponseValue;
4820 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4822 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: number): number {
4823 if(!isWasmInitialized) {
4824 throw new Error("initializeWasm() must be awaited first!");
4826 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
4827 return nativeResponseValue;
4829 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4831 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: number): number {
4832 if(!isWasmInitialized) {
4833 throw new Error("initializeWasm() must be awaited first!");
4835 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
4836 return nativeResponseValue;
4838 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4840 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: number): number {
4841 if(!isWasmInitialized) {
4842 throw new Error("initializeWasm() must be awaited first!");
4844 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
4845 return nativeResponseValue;
4847 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4849 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: number): number {
4850 if(!isWasmInitialized) {
4851 throw new Error("initializeWasm() must be awaited first!");
4853 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
4854 return nativeResponseValue;
4856 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4858 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: number): number {
4859 if(!isWasmInitialized) {
4860 throw new Error("initializeWasm() must be awaited first!");
4862 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
4863 return nativeResponseValue;
4865 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4867 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: number): number {
4868 if(!isWasmInitialized) {
4869 throw new Error("initializeWasm() must be awaited first!");
4871 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
4872 return nativeResponseValue;
4874 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4876 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: number): number {
4877 if(!isWasmInitialized) {
4878 throw new Error("initializeWasm() must be awaited first!");
4880 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
4881 return nativeResponseValue;
4883 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4885 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: number): number {
4886 if(!isWasmInitialized) {
4887 throw new Error("initializeWasm() must be awaited first!");
4889 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
4890 return nativeResponseValue;
4892 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4894 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: number): number {
4895 if(!isWasmInitialized) {
4896 throw new Error("initializeWasm() must be awaited first!");
4898 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
4899 return nativeResponseValue;
4901 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4903 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: number): number {
4904 if(!isWasmInitialized) {
4905 throw new Error("initializeWasm() must be awaited first!");
4907 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
4908 return nativeResponseValue;
4910 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4912 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: number): number {
4913 if(!isWasmInitialized) {
4914 throw new Error("initializeWasm() must be awaited first!");
4916 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
4917 return nativeResponseValue;
4919 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4921 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: number): number {
4922 if(!isWasmInitialized) {
4923 throw new Error("initializeWasm() must be awaited first!");
4925 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
4926 return nativeResponseValue;
4928 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4930 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: number): number {
4931 if(!isWasmInitialized) {
4932 throw new Error("initializeWasm() must be awaited first!");
4934 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
4935 return nativeResponseValue;
4937 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4939 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: number): number {
4940 if(!isWasmInitialized) {
4941 throw new Error("initializeWasm() must be awaited first!");
4943 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
4944 return nativeResponseValue;
4946 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4948 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: number): number {
4949 if(!isWasmInitialized) {
4950 throw new Error("initializeWasm() must be awaited first!");
4952 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
4953 return nativeResponseValue;
4955 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4957 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: number): number {
4958 if(!isWasmInitialized) {
4959 throw new Error("initializeWasm() must be awaited first!");
4961 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
4962 return nativeResponseValue;
4964 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
4966 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: number): number {
4967 if(!isWasmInitialized) {
4968 throw new Error("initializeWasm() must be awaited first!");
4970 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
4971 return nativeResponseValue;
4973 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
4975 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: number): number {
4976 if(!isWasmInitialized) {
4977 throw new Error("initializeWasm() must be awaited first!");
4979 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
4980 return nativeResponseValue;
4982 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4984 export function CResult_InitDecodeErrorZ_get_ok(owner: number): number {
4985 if(!isWasmInitialized) {
4986 throw new Error("initializeWasm() must be awaited first!");
4988 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
4989 return nativeResponseValue;
4991 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4993 export function CResult_InitDecodeErrorZ_get_err(owner: number): number {
4994 if(!isWasmInitialized) {
4995 throw new Error("initializeWasm() must be awaited first!");
4997 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
4998 return nativeResponseValue;
5000 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5002 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: number): number {
5003 if(!isWasmInitialized) {
5004 throw new Error("initializeWasm() must be awaited first!");
5006 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
5007 return nativeResponseValue;
5009 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5011 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: number): number {
5012 if(!isWasmInitialized) {
5013 throw new Error("initializeWasm() must be awaited first!");
5015 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
5016 return nativeResponseValue;
5018 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5020 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: number): number {
5021 if(!isWasmInitialized) {
5022 throw new Error("initializeWasm() must be awaited first!");
5024 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
5025 return nativeResponseValue;
5027 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5029 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: number): number {
5030 if(!isWasmInitialized) {
5031 throw new Error("initializeWasm() must be awaited first!");
5033 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
5034 return nativeResponseValue;
5036 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5038 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: number): number {
5039 if(!isWasmInitialized) {
5040 throw new Error("initializeWasm() must be awaited first!");
5042 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
5043 return nativeResponseValue;
5045 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5047 export function CResult_ShutdownDecodeErrorZ_get_err(owner: number): number {
5048 if(!isWasmInitialized) {
5049 throw new Error("initializeWasm() must be awaited first!");
5051 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
5052 return nativeResponseValue;
5054 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5056 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: number): number {
5057 if(!isWasmInitialized) {
5058 throw new Error("initializeWasm() must be awaited first!");
5060 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
5061 return nativeResponseValue;
5063 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5065 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: number): number {
5066 if(!isWasmInitialized) {
5067 throw new Error("initializeWasm() must be awaited first!");
5069 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
5070 return nativeResponseValue;
5072 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5074 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: number): number {
5075 if(!isWasmInitialized) {
5076 throw new Error("initializeWasm() must be awaited first!");
5078 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
5079 return nativeResponseValue;
5081 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5083 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: number): number {
5084 if(!isWasmInitialized) {
5085 throw new Error("initializeWasm() must be awaited first!");
5087 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
5088 return nativeResponseValue;
5090 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5092 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: number): number {
5093 if(!isWasmInitialized) {
5094 throw new Error("initializeWasm() must be awaited first!");
5096 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
5097 return nativeResponseValue;
5099 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5101 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: number): number {
5102 if(!isWasmInitialized) {
5103 throw new Error("initializeWasm() must be awaited first!");
5105 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
5106 return nativeResponseValue;
5108 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5110 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: number): number {
5111 if(!isWasmInitialized) {
5112 throw new Error("initializeWasm() must be awaited first!");
5114 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
5115 return nativeResponseValue;
5117 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5119 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: number): number {
5120 if(!isWasmInitialized) {
5121 throw new Error("initializeWasm() must be awaited first!");
5123 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
5124 return nativeResponseValue;
5126 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5128 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: number): number {
5129 if(!isWasmInitialized) {
5130 throw new Error("initializeWasm() must be awaited first!");
5132 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
5133 return nativeResponseValue;
5135 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5137 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: number): number {
5138 if(!isWasmInitialized) {
5139 throw new Error("initializeWasm() must be awaited first!");
5141 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
5142 return nativeResponseValue;
5144 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5146 export function CResult_PingDecodeErrorZ_get_ok(owner: number): number {
5147 if(!isWasmInitialized) {
5148 throw new Error("initializeWasm() must be awaited first!");
5150 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
5151 return nativeResponseValue;
5153 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5155 export function CResult_PingDecodeErrorZ_get_err(owner: number): number {
5156 if(!isWasmInitialized) {
5157 throw new Error("initializeWasm() must be awaited first!");
5159 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
5160 return nativeResponseValue;
5162 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5164 export function CResult_PongDecodeErrorZ_get_ok(owner: number): number {
5165 if(!isWasmInitialized) {
5166 throw new Error("initializeWasm() must be awaited first!");
5168 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
5169 return nativeResponseValue;
5171 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5173 export function CResult_PongDecodeErrorZ_get_err(owner: number): number {
5174 if(!isWasmInitialized) {
5175 throw new Error("initializeWasm() must be awaited first!");
5177 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
5178 return nativeResponseValue;
5180 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5182 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5183 if(!isWasmInitialized) {
5184 throw new Error("initializeWasm() must be awaited first!");
5186 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
5187 return nativeResponseValue;
5189 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5191 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5192 if(!isWasmInitialized) {
5193 throw new Error("initializeWasm() must be awaited first!");
5195 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
5196 return nativeResponseValue;
5198 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5200 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5201 if(!isWasmInitialized) {
5202 throw new Error("initializeWasm() must be awaited first!");
5204 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
5205 return nativeResponseValue;
5207 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5209 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5210 if(!isWasmInitialized) {
5211 throw new Error("initializeWasm() must be awaited first!");
5213 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
5214 return nativeResponseValue;
5216 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5218 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5219 if(!isWasmInitialized) {
5220 throw new Error("initializeWasm() must be awaited first!");
5222 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
5223 return nativeResponseValue;
5225 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5227 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5228 if(!isWasmInitialized) {
5229 throw new Error("initializeWasm() must be awaited first!");
5231 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
5232 return nativeResponseValue;
5234 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5236 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5237 if(!isWasmInitialized) {
5238 throw new Error("initializeWasm() must be awaited first!");
5240 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
5241 return nativeResponseValue;
5243 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5245 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5246 if(!isWasmInitialized) {
5247 throw new Error("initializeWasm() must be awaited first!");
5249 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
5250 return nativeResponseValue;
5252 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5254 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: number): number {
5255 if(!isWasmInitialized) {
5256 throw new Error("initializeWasm() must be awaited first!");
5258 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
5259 return nativeResponseValue;
5261 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5263 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: number): number {
5264 if(!isWasmInitialized) {
5265 throw new Error("initializeWasm() must be awaited first!");
5267 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
5268 return nativeResponseValue;
5270 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5272 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: number): number {
5273 if(!isWasmInitialized) {
5274 throw new Error("initializeWasm() must be awaited first!");
5276 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
5277 return nativeResponseValue;
5279 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5281 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: number): number {
5282 if(!isWasmInitialized) {
5283 throw new Error("initializeWasm() must be awaited first!");
5285 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
5286 return nativeResponseValue;
5288 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5290 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5291 if(!isWasmInitialized) {
5292 throw new Error("initializeWasm() must be awaited first!");
5294 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
5295 return nativeResponseValue;
5297 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5299 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5300 if(!isWasmInitialized) {
5301 throw new Error("initializeWasm() must be awaited first!");
5303 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
5304 return nativeResponseValue;
5306 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5308 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5309 if(!isWasmInitialized) {
5310 throw new Error("initializeWasm() must be awaited first!");
5312 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
5313 return nativeResponseValue;
5315 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5317 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5318 if(!isWasmInitialized) {
5319 throw new Error("initializeWasm() must be awaited first!");
5321 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
5322 return nativeResponseValue;
5324 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5326 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: number): number {
5327 if(!isWasmInitialized) {
5328 throw new Error("initializeWasm() must be awaited first!");
5330 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
5331 return nativeResponseValue;
5333 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5335 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: number): number {
5336 if(!isWasmInitialized) {
5337 throw new Error("initializeWasm() must be awaited first!");
5339 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
5340 return nativeResponseValue;
5342 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5344 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: number): number {
5345 if(!isWasmInitialized) {
5346 throw new Error("initializeWasm() must be awaited first!");
5348 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
5349 return nativeResponseValue;
5351 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5353 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: number): number {
5354 if(!isWasmInitialized) {
5355 throw new Error("initializeWasm() must be awaited first!");
5357 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
5358 return nativeResponseValue;
5360 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5362 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5363 if(!isWasmInitialized) {
5364 throw new Error("initializeWasm() must be awaited first!");
5366 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
5367 return nativeResponseValue;
5369 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5371 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: number): number {
5372 if(!isWasmInitialized) {
5373 throw new Error("initializeWasm() must be awaited first!");
5375 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
5376 return nativeResponseValue;
5378 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5380 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5381 if(!isWasmInitialized) {
5382 throw new Error("initializeWasm() must be awaited first!");
5384 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
5385 return nativeResponseValue;
5387 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5389 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: number): number {
5390 if(!isWasmInitialized) {
5391 throw new Error("initializeWasm() must be awaited first!");
5393 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
5394 return nativeResponseValue;
5396 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5398 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: number): number {
5399 if(!isWasmInitialized) {
5400 throw new Error("initializeWasm() must be awaited first!");
5402 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
5403 return nativeResponseValue;
5405 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5407 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: number): number {
5408 if(!isWasmInitialized) {
5409 throw new Error("initializeWasm() must be awaited first!");
5411 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
5412 return nativeResponseValue;
5415 export class LDKSignOrCreationError {
5416 protected constructor() {}
5419 export function LDKSignOrCreationError_ty_from_ptr(ptr: number): number {
5420 if(!isWasmInitialized) {
5421 throw new Error("initializeWasm() must be awaited first!");
5423 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
5424 return nativeResponseValue;
5427 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: number): CreationError {
5428 if(!isWasmInitialized) {
5429 throw new Error("initializeWasm() must be awaited first!");
5431 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
5432 return nativeResponseValue;
5434 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5436 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: number): number {
5437 if(!isWasmInitialized) {
5438 throw new Error("initializeWasm() must be awaited first!");
5440 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
5441 return nativeResponseValue;
5443 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5445 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: number): number {
5446 if(!isWasmInitialized) {
5447 throw new Error("initializeWasm() must be awaited first!");
5449 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
5450 return nativeResponseValue;
5453 export interface LDKFilter {
5454 register_tx (txid: number, script_pubkey: number): void;
5455 register_output (output: number): number;
5459 export function LDKFilter_new(impl: LDKFilter): number {
5460 if(!isWasmInitialized) {
5461 throw new Error("initializeWasm() must be awaited first!");
5463 var new_obj_idx = js_objs.length;
5464 for (var i = 0; i < js_objs.length; i++) {
5465 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5467 js_objs[i] = new WeakRef(impl);
5468 return wasm.TS_LDKFilter_new(i);
5470 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
5472 export function Filter_register_tx(this_arg: number, txid: number, script_pubkey: number): void {
5473 if(!isWasmInitialized) {
5474 throw new Error("initializeWasm() must be awaited first!");
5476 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
5477 // debug statements here
5479 // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
5481 export function Filter_register_output(this_arg: number, output: number): number {
5482 if(!isWasmInitialized) {
5483 throw new Error("initializeWasm() must be awaited first!");
5485 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
5486 return nativeResponseValue;
5489 export class LDKCOption_FilterZ {
5490 protected constructor() {}
5493 export function LDKCOption_FilterZ_ty_from_ptr(ptr: number): number {
5494 if(!isWasmInitialized) {
5495 throw new Error("initializeWasm() must be awaited first!");
5497 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
5498 return nativeResponseValue;
5501 export function LDKCOption_FilterZ_Some_get_some(ptr: number): number {
5502 if(!isWasmInitialized) {
5503 throw new Error("initializeWasm() must be awaited first!");
5505 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
5506 return nativeResponseValue;
5508 // struct LDKLockedChannelMonitor *CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5510 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: number): number {
5511 if(!isWasmInitialized) {
5512 throw new Error("initializeWasm() must be awaited first!");
5514 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
5515 return nativeResponseValue;
5517 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5519 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: number): void {
5520 if(!isWasmInitialized) {
5521 throw new Error("initializeWasm() must be awaited first!");
5523 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
5524 // debug statements here
5527 export interface LDKMessageSendEventsProvider {
5528 get_and_clear_pending_msg_events (): number;
5532 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): number {
5533 if(!isWasmInitialized) {
5534 throw new Error("initializeWasm() must be awaited first!");
5536 var new_obj_idx = js_objs.length;
5537 for (var i = 0; i < js_objs.length; i++) {
5538 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5540 js_objs[i] = new WeakRef(impl);
5541 return wasm.TS_LDKMessageSendEventsProvider_new(i);
5543 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
5545 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: number): number {
5546 if(!isWasmInitialized) {
5547 throw new Error("initializeWasm() must be awaited first!");
5549 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
5550 return nativeResponseValue;
5553 export interface LDKEventHandler {
5554 handle_event (event: number): void;
5558 export function LDKEventHandler_new(impl: LDKEventHandler): number {
5559 if(!isWasmInitialized) {
5560 throw new Error("initializeWasm() must be awaited first!");
5562 var new_obj_idx = js_objs.length;
5563 for (var i = 0; i < js_objs.length; i++) {
5564 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5566 js_objs[i] = new WeakRef(impl);
5567 return wasm.TS_LDKEventHandler_new(i);
5569 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
5571 export function EventHandler_handle_event(this_arg: number, event: number): void {
5572 if(!isWasmInitialized) {
5573 throw new Error("initializeWasm() must be awaited first!");
5575 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
5576 // debug statements here
5579 export interface LDKEventsProvider {
5580 process_pending_events (handler: number): void;
5584 export function LDKEventsProvider_new(impl: LDKEventsProvider): number {
5585 if(!isWasmInitialized) {
5586 throw new Error("initializeWasm() must be awaited first!");
5588 var new_obj_idx = js_objs.length;
5589 for (var i = 0; i < js_objs.length; i++) {
5590 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5592 js_objs[i] = new WeakRef(impl);
5593 return wasm.TS_LDKEventsProvider_new(i);
5595 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
5597 export function EventsProvider_process_pending_events(this_arg: number, handler: number): void {
5598 if(!isWasmInitialized) {
5599 throw new Error("initializeWasm() must be awaited first!");
5601 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
5602 // debug statements here
5605 export interface LDKScore {
5606 channel_penalty_msat (short_channel_id: bigint, source: number, target: number, usage: number): bigint;
5607 payment_path_failed (path: number, short_channel_id: bigint): void;
5608 payment_path_successful (path: number): void;
5613 export function LDKScore_new(impl: LDKScore): number {
5614 if(!isWasmInitialized) {
5615 throw new Error("initializeWasm() must be awaited first!");
5617 var new_obj_idx = js_objs.length;
5618 for (var i = 0; i < js_objs.length; i++) {
5619 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5621 js_objs[i] = new WeakRef(impl);
5622 return wasm.TS_LDKScore_new(i);
5624 // 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
5626 export function Score_channel_penalty_msat(this_arg: number, short_channel_id: bigint, source: number, target: number, usage: number): bigint {
5627 if(!isWasmInitialized) {
5628 throw new Error("initializeWasm() must be awaited first!");
5630 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage);
5631 return nativeResponseValue;
5633 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5635 export function Score_payment_path_failed(this_arg: number, path: number, short_channel_id: bigint): void {
5636 if(!isWasmInitialized) {
5637 throw new Error("initializeWasm() must be awaited first!");
5639 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
5640 // debug statements here
5642 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5644 export function Score_payment_path_successful(this_arg: number, path: number): void {
5645 if(!isWasmInitialized) {
5646 throw new Error("initializeWasm() must be awaited first!");
5648 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
5649 // debug statements here
5651 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
5653 export function Score_write(this_arg: number): number {
5654 if(!isWasmInitialized) {
5655 throw new Error("initializeWasm() must be awaited first!");
5657 const nativeResponseValue = wasm.TS_Score_write(this_arg);
5658 return nativeResponseValue;
5661 export interface LDKPersister {
5662 persist_manager (channel_manager: number): number;
5663 persist_graph (network_graph: number): number;
5664 persist_scorer (scorer: number): number;
5668 export function LDKPersister_new(impl: LDKPersister): number {
5669 if(!isWasmInitialized) {
5670 throw new Error("initializeWasm() must be awaited first!");
5672 var new_obj_idx = js_objs.length;
5673 for (var i = 0; i < js_objs.length; i++) {
5674 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5676 js_objs[i] = new WeakRef(impl);
5677 return wasm.TS_LDKPersister_new(i);
5679 // LDKCResult_NoneErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
5681 export function Persister_persist_manager(this_arg: number, channel_manager: number): number {
5682 if(!isWasmInitialized) {
5683 throw new Error("initializeWasm() must be awaited first!");
5685 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
5686 return nativeResponseValue;
5688 // LDKCResult_NoneErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
5690 export function Persister_persist_graph(this_arg: number, network_graph: number): number {
5691 if(!isWasmInitialized) {
5692 throw new Error("initializeWasm() must be awaited first!");
5694 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
5695 return nativeResponseValue;
5697 // LDKCResult_NoneErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKMultiThreadedLockableScore *NONNULL_PTR scorer
5699 export function Persister_persist_scorer(this_arg: number, scorer: number): number {
5700 if(!isWasmInitialized) {
5701 throw new Error("initializeWasm() must be awaited first!");
5703 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
5704 return nativeResponseValue;
5707 export interface LDKListen {
5708 filtered_block_connected (header: number, txdata: number, height: number): void;
5709 block_connected (block: number, height: number): void;
5710 block_disconnected (header: number, height: number): void;
5714 export function LDKListen_new(impl: LDKListen): number {
5715 if(!isWasmInitialized) {
5716 throw new Error("initializeWasm() must be awaited first!");
5718 var new_obj_idx = js_objs.length;
5719 for (var i = 0; i < js_objs.length; i++) {
5720 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5722 js_objs[i] = new WeakRef(impl);
5723 return wasm.TS_LDKListen_new(i);
5725 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5727 export function Listen_filtered_block_connected(this_arg: number, header: number, txdata: number, height: number): void {
5728 if(!isWasmInitialized) {
5729 throw new Error("initializeWasm() must be awaited first!");
5731 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
5732 // debug statements here
5734 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
5736 export function Listen_block_connected(this_arg: number, block: number, height: number): void {
5737 if(!isWasmInitialized) {
5738 throw new Error("initializeWasm() must be awaited first!");
5740 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
5741 // debug statements here
5743 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5745 export function Listen_block_disconnected(this_arg: number, header: number, height: number): void {
5746 if(!isWasmInitialized) {
5747 throw new Error("initializeWasm() must be awaited first!");
5749 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
5750 // debug statements here
5753 export interface LDKConfirm {
5754 transactions_confirmed (header: number, txdata: number, height: number): void;
5755 transaction_unconfirmed (txid: number): void;
5756 best_block_updated (header: number, height: number): void;
5757 get_relevant_txids (): number;
5761 export function LDKConfirm_new(impl: LDKConfirm): number {
5762 if(!isWasmInitialized) {
5763 throw new Error("initializeWasm() must be awaited first!");
5765 var new_obj_idx = js_objs.length;
5766 for (var i = 0; i < js_objs.length; i++) {
5767 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5769 js_objs[i] = new WeakRef(impl);
5770 return wasm.TS_LDKConfirm_new(i);
5772 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5774 export function Confirm_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number): void {
5775 if(!isWasmInitialized) {
5776 throw new Error("initializeWasm() must be awaited first!");
5778 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
5779 // debug statements here
5781 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
5783 export function Confirm_transaction_unconfirmed(this_arg: number, txid: number): void {
5784 if(!isWasmInitialized) {
5785 throw new Error("initializeWasm() must be awaited first!");
5787 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
5788 // debug statements here
5790 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5792 export function Confirm_best_block_updated(this_arg: number, header: number, height: number): void {
5793 if(!isWasmInitialized) {
5794 throw new Error("initializeWasm() must be awaited first!");
5796 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
5797 // debug statements here
5799 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
5801 export function Confirm_get_relevant_txids(this_arg: number): number {
5802 if(!isWasmInitialized) {
5803 throw new Error("initializeWasm() must be awaited first!");
5805 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
5806 return nativeResponseValue;
5809 export interface LDKPersist {
5810 persist_new_channel (channel_id: number, data: number, update_id: number): number;
5811 update_persisted_channel (channel_id: number, update: number, data: number, update_id: number): number;
5815 export function LDKPersist_new(impl: LDKPersist): 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_LDKPersist_new(i);
5826 // 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
5828 export function Persist_persist_new_channel(this_arg: number, channel_id: number, data: number, update_id: number): number {
5829 if(!isWasmInitialized) {
5830 throw new Error("initializeWasm() must be awaited first!");
5832 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
5833 return nativeResponseValue;
5835 // 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
5837 export function Persist_update_persisted_channel(this_arg: number, channel_id: number, update: number, data: number, update_id: number): number {
5838 if(!isWasmInitialized) {
5839 throw new Error("initializeWasm() must be awaited first!");
5841 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
5842 return nativeResponseValue;
5845 export interface LDKChannelMessageHandler {
5846 handle_open_channel (their_node_id: number, their_features: number, msg: number): void;
5847 handle_accept_channel (their_node_id: number, their_features: number, msg: number): void;
5848 handle_funding_created (their_node_id: number, msg: number): void;
5849 handle_funding_signed (their_node_id: number, msg: number): void;
5850 handle_channel_ready (their_node_id: number, msg: number): void;
5851 handle_shutdown (their_node_id: number, their_features: number, msg: number): void;
5852 handle_closing_signed (their_node_id: number, msg: number): void;
5853 handle_update_add_htlc (their_node_id: number, msg: number): void;
5854 handle_update_fulfill_htlc (their_node_id: number, msg: number): void;
5855 handle_update_fail_htlc (their_node_id: number, msg: number): void;
5856 handle_update_fail_malformed_htlc (their_node_id: number, msg: number): void;
5857 handle_commitment_signed (their_node_id: number, msg: number): void;
5858 handle_revoke_and_ack (their_node_id: number, msg: number): void;
5859 handle_update_fee (their_node_id: number, msg: number): void;
5860 handle_announcement_signatures (their_node_id: number, msg: number): void;
5861 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
5862 peer_connected (their_node_id: number, msg: number): void;
5863 handle_channel_reestablish (their_node_id: number, msg: number): void;
5864 handle_channel_update (their_node_id: number, msg: number): void;
5865 handle_error (their_node_id: number, msg: number): void;
5869 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
5870 if(!isWasmInitialized) {
5871 throw new Error("initializeWasm() must be awaited first!");
5873 var new_obj_idx = js_objs.length;
5874 for (var i = 0; i < js_objs.length; i++) {
5875 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5877 js_objs[i] = new WeakRef(impl);
5878 return wasm.TS_LDKChannelMessageHandler_new(i);
5880 // 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
5882 export function ChannelMessageHandler_handle_open_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5883 if(!isWasmInitialized) {
5884 throw new Error("initializeWasm() must be awaited first!");
5886 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
5887 // debug statements here
5889 // 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
5891 export function ChannelMessageHandler_handle_accept_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5892 if(!isWasmInitialized) {
5893 throw new Error("initializeWasm() must be awaited first!");
5895 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
5896 // debug statements here
5898 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
5900 export function ChannelMessageHandler_handle_funding_created(this_arg: number, their_node_id: number, msg: number): void {
5901 if(!isWasmInitialized) {
5902 throw new Error("initializeWasm() must be awaited first!");
5904 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
5905 // debug statements here
5907 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
5909 export function ChannelMessageHandler_handle_funding_signed(this_arg: number, their_node_id: number, msg: number): void {
5910 if(!isWasmInitialized) {
5911 throw new Error("initializeWasm() must be awaited first!");
5913 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
5914 // debug statements here
5916 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
5918 export function ChannelMessageHandler_handle_channel_ready(this_arg: number, their_node_id: number, msg: number): void {
5919 if(!isWasmInitialized) {
5920 throw new Error("initializeWasm() must be awaited first!");
5922 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
5923 // debug statements here
5925 // 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
5927 export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5928 if(!isWasmInitialized) {
5929 throw new Error("initializeWasm() must be awaited first!");
5931 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
5932 // debug statements here
5934 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
5936 export function ChannelMessageHandler_handle_closing_signed(this_arg: number, their_node_id: number, msg: number): void {
5937 if(!isWasmInitialized) {
5938 throw new Error("initializeWasm() must be awaited first!");
5940 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
5941 // debug statements here
5943 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
5945 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: number, their_node_id: number, msg: number): void {
5946 if(!isWasmInitialized) {
5947 throw new Error("initializeWasm() must be awaited first!");
5949 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
5950 // debug statements here
5952 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
5954 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: number, their_node_id: number, msg: number): void {
5955 if(!isWasmInitialized) {
5956 throw new Error("initializeWasm() must be awaited first!");
5958 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
5959 // debug statements here
5961 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
5963 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: number, their_node_id: number, msg: number): void {
5964 if(!isWasmInitialized) {
5965 throw new Error("initializeWasm() must be awaited first!");
5967 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
5968 // debug statements here
5970 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
5972 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: number, their_node_id: number, msg: number): void {
5973 if(!isWasmInitialized) {
5974 throw new Error("initializeWasm() must be awaited first!");
5976 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
5977 // debug statements here
5979 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
5981 export function ChannelMessageHandler_handle_commitment_signed(this_arg: number, their_node_id: number, msg: number): void {
5982 if(!isWasmInitialized) {
5983 throw new Error("initializeWasm() must be awaited first!");
5985 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
5986 // debug statements here
5988 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
5990 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: number, their_node_id: number, msg: number): void {
5991 if(!isWasmInitialized) {
5992 throw new Error("initializeWasm() must be awaited first!");
5994 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
5995 // debug statements here
5997 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
5999 export function ChannelMessageHandler_handle_update_fee(this_arg: number, their_node_id: number, msg: number): void {
6000 if(!isWasmInitialized) {
6001 throw new Error("initializeWasm() must be awaited first!");
6003 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
6004 // debug statements here
6006 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
6008 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: number, their_node_id: number, msg: number): void {
6009 if(!isWasmInitialized) {
6010 throw new Error("initializeWasm() must be awaited first!");
6012 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
6013 // debug statements here
6015 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
6017 export function ChannelMessageHandler_peer_disconnected(this_arg: number, their_node_id: number, no_connection_possible: boolean): void {
6018 if(!isWasmInitialized) {
6019 throw new Error("initializeWasm() must be awaited first!");
6021 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
6022 // debug statements here
6024 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
6026 export function ChannelMessageHandler_peer_connected(this_arg: number, their_node_id: number, msg: number): void {
6027 if(!isWasmInitialized) {
6028 throw new Error("initializeWasm() must be awaited first!");
6030 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
6031 // debug statements here
6033 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
6035 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: number, their_node_id: number, msg: number): void {
6036 if(!isWasmInitialized) {
6037 throw new Error("initializeWasm() must be awaited first!");
6039 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
6040 // debug statements here
6042 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
6044 export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: number, msg: number): void {
6045 if(!isWasmInitialized) {
6046 throw new Error("initializeWasm() must be awaited first!");
6048 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
6049 // debug statements here
6051 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
6053 export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: number, msg: number): void {
6054 if(!isWasmInitialized) {
6055 throw new Error("initializeWasm() must be awaited first!");
6057 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
6058 // debug statements here
6061 export interface LDKRoutingMessageHandler {
6062 handle_node_announcement (msg: number): number;
6063 handle_channel_announcement (msg: number): number;
6064 handle_channel_update (msg: number): number;
6065 get_next_channel_announcements (starting_point: bigint, batch_amount: number): number;
6066 get_next_node_announcements (starting_point: number, batch_amount: number): number;
6067 peer_connected (their_node_id: number, init: number): void;
6068 handle_reply_channel_range (their_node_id: number, msg: number): number;
6069 handle_reply_short_channel_ids_end (their_node_id: number, msg: number): number;
6070 handle_query_channel_range (their_node_id: number, msg: number): number;
6071 handle_query_short_channel_ids (their_node_id: number, msg: number): number;
6075 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
6076 if(!isWasmInitialized) {
6077 throw new Error("initializeWasm() must be awaited first!");
6079 var new_obj_idx = js_objs.length;
6080 for (var i = 0; i < js_objs.length; i++) {
6081 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6083 js_objs[i] = new WeakRef(impl);
6084 return wasm.TS_LDKRoutingMessageHandler_new(i);
6086 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
6088 export function RoutingMessageHandler_handle_node_announcement(this_arg: number, msg: number): number {
6089 if(!isWasmInitialized) {
6090 throw new Error("initializeWasm() must be awaited first!");
6092 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
6093 return nativeResponseValue;
6095 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
6097 export function RoutingMessageHandler_handle_channel_announcement(this_arg: number, msg: number): number {
6098 if(!isWasmInitialized) {
6099 throw new Error("initializeWasm() must be awaited first!");
6101 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
6102 return nativeResponseValue;
6104 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
6106 export function RoutingMessageHandler_handle_channel_update(this_arg: number, msg: number): number {
6107 if(!isWasmInitialized) {
6108 throw new Error("initializeWasm() must be awaited first!");
6110 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
6111 return nativeResponseValue;
6113 // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
6115 export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: bigint, batch_amount: number): number {
6116 if(!isWasmInitialized) {
6117 throw new Error("initializeWasm() must be awaited first!");
6119 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
6120 return nativeResponseValue;
6122 // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
6124 export function RoutingMessageHandler_get_next_node_announcements(this_arg: number, starting_point: number, batch_amount: number): number {
6125 if(!isWasmInitialized) {
6126 throw new Error("initializeWasm() must be awaited first!");
6128 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcements(this_arg, starting_point, batch_amount);
6129 return nativeResponseValue;
6131 // void RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
6133 export function RoutingMessageHandler_peer_connected(this_arg: number, their_node_id: number, init: number): void {
6134 if(!isWasmInitialized) {
6135 throw new Error("initializeWasm() must be awaited first!");
6137 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init);
6138 // debug statements here
6140 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
6142 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: number, their_node_id: number, msg: number): number {
6143 if(!isWasmInitialized) {
6144 throw new Error("initializeWasm() must be awaited first!");
6146 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
6147 return nativeResponseValue;
6149 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
6151 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: number, their_node_id: number, msg: number): number {
6152 if(!isWasmInitialized) {
6153 throw new Error("initializeWasm() must be awaited first!");
6155 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
6156 return nativeResponseValue;
6158 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
6160 export function RoutingMessageHandler_handle_query_channel_range(this_arg: number, their_node_id: number, msg: number): number {
6161 if(!isWasmInitialized) {
6162 throw new Error("initializeWasm() must be awaited first!");
6164 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
6165 return nativeResponseValue;
6167 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
6169 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: number, their_node_id: number, msg: number): number {
6170 if(!isWasmInitialized) {
6171 throw new Error("initializeWasm() must be awaited first!");
6173 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
6174 return nativeResponseValue;
6177 export interface LDKCustomMessageReader {
6178 read (message_type: number, buffer: number): number;
6182 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): number {
6183 if(!isWasmInitialized) {
6184 throw new Error("initializeWasm() must be awaited first!");
6186 var new_obj_idx = js_objs.length;
6187 for (var i = 0; i < js_objs.length; i++) {
6188 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6190 js_objs[i] = new WeakRef(impl);
6191 return wasm.TS_LDKCustomMessageReader_new(i);
6193 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
6195 export function CustomMessageReader_read(this_arg: number, message_type: number, buffer: number): number {
6196 if(!isWasmInitialized) {
6197 throw new Error("initializeWasm() must be awaited first!");
6199 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
6200 return nativeResponseValue;
6203 export interface LDKCustomMessageHandler {
6204 handle_custom_message (msg: number, sender_node_id: number): number;
6205 get_and_clear_pending_msg (): number;
6209 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): number {
6210 if(!isWasmInitialized) {
6211 throw new Error("initializeWasm() must be awaited first!");
6213 var new_obj_idx = js_objs.length;
6214 for (var i = 0; i < js_objs.length; i++) {
6215 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6217 js_objs[i] = new WeakRef(impl);
6218 return wasm.TS_LDKCustomMessageHandler_new(i);
6220 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
6222 export function CustomMessageHandler_handle_custom_message(this_arg: number, msg: number, sender_node_id: number): number {
6223 if(!isWasmInitialized) {
6224 throw new Error("initializeWasm() must be awaited first!");
6226 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
6227 return nativeResponseValue;
6229 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
6231 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: number): number {
6232 if(!isWasmInitialized) {
6233 throw new Error("initializeWasm() must be awaited first!");
6235 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
6236 return nativeResponseValue;
6239 export interface LDKSocketDescriptor {
6240 send_data (data: number, resume_read: boolean): number;
6241 disconnect_socket (): void;
6242 eq (other_arg: number): boolean;
6247 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): number {
6248 if(!isWasmInitialized) {
6249 throw new Error("initializeWasm() must be awaited first!");
6251 var new_obj_idx = js_objs.length;
6252 for (var i = 0; i < js_objs.length; i++) {
6253 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6255 js_objs[i] = new WeakRef(impl);
6256 return wasm.TS_LDKSocketDescriptor_new(i);
6258 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
6260 export function SocketDescriptor_send_data(this_arg: number, data: number, resume_read: boolean): number {
6261 if(!isWasmInitialized) {
6262 throw new Error("initializeWasm() must be awaited first!");
6264 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
6265 return nativeResponseValue;
6267 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
6269 export function SocketDescriptor_disconnect_socket(this_arg: number): void {
6270 if(!isWasmInitialized) {
6271 throw new Error("initializeWasm() must be awaited first!");
6273 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
6274 // debug statements here
6276 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
6278 export function SocketDescriptor_hash(this_arg: number): bigint {
6279 if(!isWasmInitialized) {
6280 throw new Error("initializeWasm() must be awaited first!");
6282 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
6283 return nativeResponseValue;
6286 export class LDKEffectiveCapacity {
6287 protected constructor() {}
6290 export function LDKEffectiveCapacity_ty_from_ptr(ptr: number): number {
6291 if(!isWasmInitialized) {
6292 throw new Error("initializeWasm() must be awaited first!");
6294 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
6295 return nativeResponseValue;
6298 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: number): bigint {
6299 if(!isWasmInitialized) {
6300 throw new Error("initializeWasm() must be awaited first!");
6302 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
6303 return nativeResponseValue;
6306 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: number): bigint {
6307 if(!isWasmInitialized) {
6308 throw new Error("initializeWasm() must be awaited first!");
6310 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
6311 return nativeResponseValue;
6314 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: number): bigint {
6315 if(!isWasmInitialized) {
6316 throw new Error("initializeWasm() must be awaited first!");
6318 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
6319 return nativeResponseValue;
6322 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: number): number {
6323 if(!isWasmInitialized) {
6324 throw new Error("initializeWasm() must be awaited first!");
6326 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
6327 return nativeResponseValue;
6330 export interface LDKLockableScore {
6335 export function LDKLockableScore_new(impl: LDKLockableScore): number {
6336 if(!isWasmInitialized) {
6337 throw new Error("initializeWasm() must be awaited first!");
6339 var new_obj_idx = js_objs.length;
6340 for (var i = 0; i < js_objs.length; i++) {
6341 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6343 js_objs[i] = new WeakRef(impl);
6344 return wasm.TS_LDKLockableScore_new(i);
6346 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
6348 export function LockableScore_lock(this_arg: number): number {
6349 if(!isWasmInitialized) {
6350 throw new Error("initializeWasm() must be awaited first!");
6352 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
6353 return nativeResponseValue;
6356 export class LDKFallback {
6357 protected constructor() {}
6360 export function LDKFallback_ty_from_ptr(ptr: number): number {
6361 if(!isWasmInitialized) {
6362 throw new Error("initializeWasm() must be awaited first!");
6364 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
6365 return nativeResponseValue;
6368 export function LDKFallback_SegWitProgram_get_version(ptr: number): number {
6369 if(!isWasmInitialized) {
6370 throw new Error("initializeWasm() must be awaited first!");
6372 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
6373 return nativeResponseValue;
6376 export function LDKFallback_SegWitProgram_get_program(ptr: number): number {
6377 if(!isWasmInitialized) {
6378 throw new Error("initializeWasm() must be awaited first!");
6380 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
6381 return nativeResponseValue;
6384 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: number): number {
6385 if(!isWasmInitialized) {
6386 throw new Error("initializeWasm() must be awaited first!");
6388 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
6389 return nativeResponseValue;
6392 export function LDKFallback_ScriptHash_get_script_hash(ptr: number): number {
6393 if(!isWasmInitialized) {
6394 throw new Error("initializeWasm() must be awaited first!");
6396 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
6397 return nativeResponseValue;
6400 export interface LDKPayer {
6402 first_hops (): number;
6403 send_payment (route: number, payment_hash: number, payment_secret: number): number;
6404 send_spontaneous_payment (route: number, payment_preimage: number): number;
6405 retry_payment (route: number, payment_id: number): number;
6406 abandon_payment (payment_id: number): void;
6410 export function LDKPayer_new(impl: LDKPayer): number {
6411 if(!isWasmInitialized) {
6412 throw new Error("initializeWasm() must be awaited first!");
6414 var new_obj_idx = js_objs.length;
6415 for (var i = 0; i < js_objs.length; i++) {
6416 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6418 js_objs[i] = new WeakRef(impl);
6419 return wasm.TS_LDKPayer_new(i);
6421 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
6423 export function Payer_node_id(this_arg: number): number {
6424 if(!isWasmInitialized) {
6425 throw new Error("initializeWasm() must be awaited first!");
6427 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
6428 return nativeResponseValue;
6430 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
6432 export function Payer_first_hops(this_arg: number): number {
6433 if(!isWasmInitialized) {
6434 throw new Error("initializeWasm() must be awaited first!");
6436 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
6437 return nativeResponseValue;
6439 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret
6441 export function Payer_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
6442 if(!isWasmInitialized) {
6443 throw new Error("initializeWasm() must be awaited first!");
6445 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret);
6446 return nativeResponseValue;
6448 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage
6450 export function Payer_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
6451 if(!isWasmInitialized) {
6452 throw new Error("initializeWasm() must be awaited first!");
6454 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage);
6455 return nativeResponseValue;
6457 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
6459 export function Payer_retry_payment(this_arg: number, route: number, payment_id: number): number {
6460 if(!isWasmInitialized) {
6461 throw new Error("initializeWasm() must be awaited first!");
6463 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
6464 return nativeResponseValue;
6466 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
6468 export function Payer_abandon_payment(this_arg: number, payment_id: number): void {
6469 if(!isWasmInitialized) {
6470 throw new Error("initializeWasm() must be awaited first!");
6472 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
6473 // debug statements here
6476 export interface LDKRouter {
6477 find_route (payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number;
6481 export function LDKRouter_new(impl: LDKRouter): number {
6482 if(!isWasmInitialized) {
6483 throw new Error("initializeWasm() must be awaited first!");
6485 var new_obj_idx = js_objs.length;
6486 for (var i = 0; i < js_objs.length; i++) {
6487 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6489 js_objs[i] = new WeakRef(impl);
6490 return wasm.TS_LDKRouter_new(i);
6492 // 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
6494 export function Router_find_route(this_arg: number, payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number {
6495 if(!isWasmInitialized) {
6496 throw new Error("initializeWasm() must be awaited first!");
6498 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, payment_hash, first_hops, scorer);
6499 return nativeResponseValue;
6502 export class LDKRetry {
6503 protected constructor() {}
6506 export function LDKRetry_ty_from_ptr(ptr: number): number {
6507 if(!isWasmInitialized) {
6508 throw new Error("initializeWasm() must be awaited first!");
6510 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
6511 return nativeResponseValue;
6514 export function LDKRetry_Attempts_get_attempts(ptr: number): number {
6515 if(!isWasmInitialized) {
6516 throw new Error("initializeWasm() must be awaited first!");
6518 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
6519 return nativeResponseValue;
6521 // struct LDKStr _ldk_get_compiled_version(void);
6523 export function _ldk_get_compiled_version(): number {
6524 if(!isWasmInitialized) {
6525 throw new Error("initializeWasm() must be awaited first!");
6527 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
6528 return nativeResponseValue;
6530 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
6532 export function _ldk_c_bindings_get_compiled_version(): number {
6533 if(!isWasmInitialized) {
6534 throw new Error("initializeWasm() must be awaited first!");
6536 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
6537 return nativeResponseValue;
6539 // uintptr_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
6541 export function Bech32Error_clone_ptr(arg: number): number {
6542 if(!isWasmInitialized) {
6543 throw new Error("initializeWasm() must be awaited first!");
6545 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
6546 return nativeResponseValue;
6548 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
6550 export function Bech32Error_clone(orig: number): number {
6551 if(!isWasmInitialized) {
6552 throw new Error("initializeWasm() must be awaited first!");
6554 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
6555 return nativeResponseValue;
6557 // void Bech32Error_free(struct LDKBech32Error o);
6559 export function Bech32Error_free(o: number): void {
6560 if(!isWasmInitialized) {
6561 throw new Error("initializeWasm() must be awaited first!");
6563 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
6564 // debug statements here
6566 // void Transaction_free(struct LDKTransaction _res);
6568 export function Transaction_free(_res: number): void {
6569 if(!isWasmInitialized) {
6570 throw new Error("initializeWasm() must be awaited first!");
6572 const nativeResponseValue = wasm.TS_Transaction_free(_res);
6573 // debug statements here
6575 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
6577 export function TxOut_new(script_pubkey: number, value: bigint): number {
6578 if(!isWasmInitialized) {
6579 throw new Error("initializeWasm() must be awaited first!");
6581 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
6582 return nativeResponseValue;
6584 // void TxOut_free(struct LDKTxOut _res);
6586 export function TxOut_free(_res: number): void {
6587 if(!isWasmInitialized) {
6588 throw new Error("initializeWasm() must be awaited first!");
6590 const nativeResponseValue = wasm.TS_TxOut_free(_res);
6591 // debug statements here
6593 // uintptr_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
6595 export function TxOut_clone_ptr(arg: number): number {
6596 if(!isWasmInitialized) {
6597 throw new Error("initializeWasm() must be awaited first!");
6599 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
6600 return nativeResponseValue;
6602 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
6604 export function TxOut_clone(orig: number): number {
6605 if(!isWasmInitialized) {
6606 throw new Error("initializeWasm() must be awaited first!");
6608 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
6609 return nativeResponseValue;
6611 // void Str_free(struct LDKStr _res);
6613 export function Str_free(_res: number): void {
6614 if(!isWasmInitialized) {
6615 throw new Error("initializeWasm() must be awaited first!");
6617 const nativeResponseValue = wasm.TS_Str_free(_res);
6618 // debug statements here
6620 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
6622 export function CResult_NoneNoneZ_ok(): number {
6623 if(!isWasmInitialized) {
6624 throw new Error("initializeWasm() must be awaited first!");
6626 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
6627 return nativeResponseValue;
6629 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
6631 export function CResult_NoneNoneZ_err(): number {
6632 if(!isWasmInitialized) {
6633 throw new Error("initializeWasm() must be awaited first!");
6635 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
6636 return nativeResponseValue;
6638 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
6640 export function CResult_NoneNoneZ_is_ok(o: number): boolean {
6641 if(!isWasmInitialized) {
6642 throw new Error("initializeWasm() must be awaited first!");
6644 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
6645 return nativeResponseValue;
6647 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
6649 export function CResult_NoneNoneZ_free(_res: number): void {
6650 if(!isWasmInitialized) {
6651 throw new Error("initializeWasm() must be awaited first!");
6653 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
6654 // debug statements here
6656 // uintptr_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
6658 export function CResult_NoneNoneZ_clone_ptr(arg: number): number {
6659 if(!isWasmInitialized) {
6660 throw new Error("initializeWasm() must be awaited first!");
6662 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
6663 return nativeResponseValue;
6665 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
6667 export function CResult_NoneNoneZ_clone(orig: number): number {
6668 if(!isWasmInitialized) {
6669 throw new Error("initializeWasm() must be awaited first!");
6671 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
6672 return nativeResponseValue;
6674 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
6676 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: number): number {
6677 if(!isWasmInitialized) {
6678 throw new Error("initializeWasm() must be awaited first!");
6680 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
6681 return nativeResponseValue;
6683 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
6685 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: number): number {
6686 if(!isWasmInitialized) {
6687 throw new Error("initializeWasm() must be awaited first!");
6689 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
6690 return nativeResponseValue;
6692 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
6694 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: number): boolean {
6695 if(!isWasmInitialized) {
6696 throw new Error("initializeWasm() must be awaited first!");
6698 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
6699 return nativeResponseValue;
6701 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
6703 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: number): void {
6704 if(!isWasmInitialized) {
6705 throw new Error("initializeWasm() must be awaited first!");
6707 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
6708 // debug statements here
6710 // uintptr_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
6712 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: number): number {
6713 if(!isWasmInitialized) {
6714 throw new Error("initializeWasm() must be awaited first!");
6716 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
6717 return nativeResponseValue;
6719 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
6721 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: number): number {
6722 if(!isWasmInitialized) {
6723 throw new Error("initializeWasm() must be awaited first!");
6725 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
6726 return nativeResponseValue;
6728 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
6730 export function CResult_SecretKeyErrorZ_ok(o: number): number {
6731 if(!isWasmInitialized) {
6732 throw new Error("initializeWasm() must be awaited first!");
6734 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
6735 return nativeResponseValue;
6737 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
6739 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): number {
6740 if(!isWasmInitialized) {
6741 throw new Error("initializeWasm() must be awaited first!");
6743 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
6744 return nativeResponseValue;
6746 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
6748 export function CResult_SecretKeyErrorZ_is_ok(o: number): boolean {
6749 if(!isWasmInitialized) {
6750 throw new Error("initializeWasm() must be awaited first!");
6752 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
6753 return nativeResponseValue;
6755 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
6757 export function CResult_SecretKeyErrorZ_free(_res: number): void {
6758 if(!isWasmInitialized) {
6759 throw new Error("initializeWasm() must be awaited first!");
6761 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
6762 // debug statements here
6764 // uintptr_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg);
6766 export function CResult_SecretKeyErrorZ_clone_ptr(arg: number): number {
6767 if(!isWasmInitialized) {
6768 throw new Error("initializeWasm() must be awaited first!");
6770 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone_ptr(arg);
6771 return nativeResponseValue;
6773 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_clone(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR orig);
6775 export function CResult_SecretKeyErrorZ_clone(orig: number): number {
6776 if(!isWasmInitialized) {
6777 throw new Error("initializeWasm() must be awaited first!");
6779 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone(orig);
6780 return nativeResponseValue;
6782 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
6784 export function CResult_PublicKeyErrorZ_ok(o: number): number {
6785 if(!isWasmInitialized) {
6786 throw new Error("initializeWasm() must be awaited first!");
6788 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
6789 return nativeResponseValue;
6791 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
6793 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): number {
6794 if(!isWasmInitialized) {
6795 throw new Error("initializeWasm() must be awaited first!");
6797 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
6798 return nativeResponseValue;
6800 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
6802 export function CResult_PublicKeyErrorZ_is_ok(o: number): boolean {
6803 if(!isWasmInitialized) {
6804 throw new Error("initializeWasm() must be awaited first!");
6806 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
6807 return nativeResponseValue;
6809 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
6811 export function CResult_PublicKeyErrorZ_free(_res: number): void {
6812 if(!isWasmInitialized) {
6813 throw new Error("initializeWasm() must be awaited first!");
6815 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
6816 // debug statements here
6818 // uintptr_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
6820 export function CResult_PublicKeyErrorZ_clone_ptr(arg: number): number {
6821 if(!isWasmInitialized) {
6822 throw new Error("initializeWasm() must be awaited first!");
6824 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
6825 return nativeResponseValue;
6827 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
6829 export function CResult_PublicKeyErrorZ_clone(orig: number): number {
6830 if(!isWasmInitialized) {
6831 throw new Error("initializeWasm() must be awaited first!");
6833 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
6834 return nativeResponseValue;
6836 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
6838 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: number): number {
6839 if(!isWasmInitialized) {
6840 throw new Error("initializeWasm() must be awaited first!");
6842 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
6843 return nativeResponseValue;
6845 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
6847 export function CResult_TxCreationKeysDecodeErrorZ_err(e: number): number {
6848 if(!isWasmInitialized) {
6849 throw new Error("initializeWasm() must be awaited first!");
6851 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
6852 return nativeResponseValue;
6854 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
6856 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: number): boolean {
6857 if(!isWasmInitialized) {
6858 throw new Error("initializeWasm() must be awaited first!");
6860 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
6861 return nativeResponseValue;
6863 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
6865 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
6866 if(!isWasmInitialized) {
6867 throw new Error("initializeWasm() must be awaited first!");
6869 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
6870 // debug statements here
6872 // uintptr_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
6874 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: number): number {
6875 if(!isWasmInitialized) {
6876 throw new Error("initializeWasm() must be awaited first!");
6878 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
6879 return nativeResponseValue;
6881 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
6883 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: number): number {
6884 if(!isWasmInitialized) {
6885 throw new Error("initializeWasm() must be awaited first!");
6887 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
6888 return nativeResponseValue;
6890 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
6892 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: number): number {
6893 if(!isWasmInitialized) {
6894 throw new Error("initializeWasm() must be awaited first!");
6896 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
6897 return nativeResponseValue;
6899 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
6901 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: number): number {
6902 if(!isWasmInitialized) {
6903 throw new Error("initializeWasm() must be awaited first!");
6905 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
6906 return nativeResponseValue;
6908 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
6910 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: number): boolean {
6911 if(!isWasmInitialized) {
6912 throw new Error("initializeWasm() must be awaited first!");
6914 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
6915 return nativeResponseValue;
6917 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
6919 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: number): void {
6920 if(!isWasmInitialized) {
6921 throw new Error("initializeWasm() must be awaited first!");
6923 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
6924 // debug statements here
6926 // uintptr_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
6928 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: number): number {
6929 if(!isWasmInitialized) {
6930 throw new Error("initializeWasm() must be awaited first!");
6932 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
6933 return nativeResponseValue;
6935 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
6937 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: number): number {
6938 if(!isWasmInitialized) {
6939 throw new Error("initializeWasm() must be awaited first!");
6941 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
6942 return nativeResponseValue;
6944 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
6946 export function CResult_TxCreationKeysErrorZ_ok(o: number): number {
6947 if(!isWasmInitialized) {
6948 throw new Error("initializeWasm() must be awaited first!");
6950 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
6951 return nativeResponseValue;
6953 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
6955 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): number {
6956 if(!isWasmInitialized) {
6957 throw new Error("initializeWasm() must be awaited first!");
6959 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
6960 return nativeResponseValue;
6962 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
6964 export function CResult_TxCreationKeysErrorZ_is_ok(o: number): boolean {
6965 if(!isWasmInitialized) {
6966 throw new Error("initializeWasm() must be awaited first!");
6968 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
6969 return nativeResponseValue;
6971 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
6973 export function CResult_TxCreationKeysErrorZ_free(_res: number): void {
6974 if(!isWasmInitialized) {
6975 throw new Error("initializeWasm() must be awaited first!");
6977 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
6978 // debug statements here
6980 // uintptr_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
6982 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: number): number {
6983 if(!isWasmInitialized) {
6984 throw new Error("initializeWasm() must be awaited first!");
6986 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
6987 return nativeResponseValue;
6989 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
6991 export function CResult_TxCreationKeysErrorZ_clone(orig: number): number {
6992 if(!isWasmInitialized) {
6993 throw new Error("initializeWasm() must be awaited first!");
6995 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
6996 return nativeResponseValue;
6998 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
7000 export function COption_u32Z_some(o: number): number {
7001 if(!isWasmInitialized) {
7002 throw new Error("initializeWasm() must be awaited first!");
7004 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
7005 return nativeResponseValue;
7007 // struct LDKCOption_u32Z COption_u32Z_none(void);
7009 export function COption_u32Z_none(): number {
7010 if(!isWasmInitialized) {
7011 throw new Error("initializeWasm() must be awaited first!");
7013 const nativeResponseValue = wasm.TS_COption_u32Z_none();
7014 return nativeResponseValue;
7016 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
7018 export function COption_u32Z_free(_res: number): void {
7019 if(!isWasmInitialized) {
7020 throw new Error("initializeWasm() must be awaited first!");
7022 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
7023 // debug statements here
7025 // uintptr_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
7027 export function COption_u32Z_clone_ptr(arg: number): number {
7028 if(!isWasmInitialized) {
7029 throw new Error("initializeWasm() must be awaited first!");
7031 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
7032 return nativeResponseValue;
7034 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
7036 export function COption_u32Z_clone(orig: number): number {
7037 if(!isWasmInitialized) {
7038 throw new Error("initializeWasm() must be awaited first!");
7040 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
7041 return nativeResponseValue;
7043 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
7045 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
7046 if(!isWasmInitialized) {
7047 throw new Error("initializeWasm() must be awaited first!");
7049 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
7050 return nativeResponseValue;
7052 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
7054 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: number): number {
7055 if(!isWasmInitialized) {
7056 throw new Error("initializeWasm() must be awaited first!");
7058 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
7059 return nativeResponseValue;
7061 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
7063 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: number): boolean {
7064 if(!isWasmInitialized) {
7065 throw new Error("initializeWasm() must be awaited first!");
7067 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
7068 return nativeResponseValue;
7070 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
7072 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: number): void {
7073 if(!isWasmInitialized) {
7074 throw new Error("initializeWasm() must be awaited first!");
7076 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
7077 // debug statements here
7079 // uintptr_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
7081 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: number): number {
7082 if(!isWasmInitialized) {
7083 throw new Error("initializeWasm() must be awaited first!");
7085 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
7086 return nativeResponseValue;
7088 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
7090 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: number): number {
7091 if(!isWasmInitialized) {
7092 throw new Error("initializeWasm() must be awaited first!");
7094 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
7095 return nativeResponseValue;
7097 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
7099 export function COption_NoneZ_some(): COption_NoneZ {
7100 if(!isWasmInitialized) {
7101 throw new Error("initializeWasm() must be awaited first!");
7103 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
7104 return nativeResponseValue;
7106 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
7108 export function COption_NoneZ_none(): COption_NoneZ {
7109 if(!isWasmInitialized) {
7110 throw new Error("initializeWasm() must be awaited first!");
7112 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
7113 return nativeResponseValue;
7115 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
7117 export function COption_NoneZ_free(_res: COption_NoneZ): void {
7118 if(!isWasmInitialized) {
7119 throw new Error("initializeWasm() must be awaited first!");
7121 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
7122 // debug statements here
7124 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
7126 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
7127 if(!isWasmInitialized) {
7128 throw new Error("initializeWasm() must be awaited first!");
7130 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
7131 return nativeResponseValue;
7133 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7135 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: number): number {
7136 if(!isWasmInitialized) {
7137 throw new Error("initializeWasm() must be awaited first!");
7139 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
7140 return nativeResponseValue;
7142 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7144 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
7145 if(!isWasmInitialized) {
7146 throw new Error("initializeWasm() must be awaited first!");
7148 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
7149 return nativeResponseValue;
7151 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
7153 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
7154 if(!isWasmInitialized) {
7155 throw new Error("initializeWasm() must be awaited first!");
7157 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
7158 // debug statements here
7160 // uintptr_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7162 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
7163 if(!isWasmInitialized) {
7164 throw new Error("initializeWasm() must be awaited first!");
7166 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7167 return nativeResponseValue;
7169 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7171 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
7172 if(!isWasmInitialized) {
7173 throw new Error("initializeWasm() must be awaited first!");
7175 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
7176 return nativeResponseValue;
7178 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
7180 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
7181 if(!isWasmInitialized) {
7182 throw new Error("initializeWasm() must be awaited first!");
7184 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
7185 return nativeResponseValue;
7187 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7189 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: number): number {
7190 if(!isWasmInitialized) {
7191 throw new Error("initializeWasm() must be awaited first!");
7193 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
7194 return nativeResponseValue;
7196 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7198 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
7199 if(!isWasmInitialized) {
7200 throw new Error("initializeWasm() must be awaited first!");
7202 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
7203 return nativeResponseValue;
7205 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
7207 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
7208 if(!isWasmInitialized) {
7209 throw new Error("initializeWasm() must be awaited first!");
7211 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
7212 // debug statements here
7214 // uintptr_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7216 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
7217 if(!isWasmInitialized) {
7218 throw new Error("initializeWasm() must be awaited first!");
7220 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7221 return nativeResponseValue;
7223 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7225 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
7226 if(!isWasmInitialized) {
7227 throw new Error("initializeWasm() must be awaited first!");
7229 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
7230 return nativeResponseValue;
7232 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
7234 export function CVec_SignatureZ_free(_res: number): void {
7235 if(!isWasmInitialized) {
7236 throw new Error("initializeWasm() must be awaited first!");
7238 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
7239 // debug statements here
7241 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
7243 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7244 if(!isWasmInitialized) {
7245 throw new Error("initializeWasm() must be awaited first!");
7247 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
7248 return nativeResponseValue;
7250 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7252 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: number): number {
7253 if(!isWasmInitialized) {
7254 throw new Error("initializeWasm() must be awaited first!");
7256 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
7257 return nativeResponseValue;
7259 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7261 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7262 if(!isWasmInitialized) {
7263 throw new Error("initializeWasm() must be awaited first!");
7265 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
7266 return nativeResponseValue;
7268 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
7270 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7271 if(!isWasmInitialized) {
7272 throw new Error("initializeWasm() must be awaited first!");
7274 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
7275 // debug statements here
7277 // uintptr_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7279 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7280 if(!isWasmInitialized) {
7281 throw new Error("initializeWasm() must be awaited first!");
7283 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7284 return nativeResponseValue;
7286 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7288 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7289 if(!isWasmInitialized) {
7290 throw new Error("initializeWasm() must be awaited first!");
7292 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
7293 return nativeResponseValue;
7295 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
7297 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7298 if(!isWasmInitialized) {
7299 throw new Error("initializeWasm() must be awaited first!");
7301 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
7302 return nativeResponseValue;
7304 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7306 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: number): number {
7307 if(!isWasmInitialized) {
7308 throw new Error("initializeWasm() must be awaited first!");
7310 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
7311 return nativeResponseValue;
7313 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7315 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7316 if(!isWasmInitialized) {
7317 throw new Error("initializeWasm() must be awaited first!");
7319 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
7320 return nativeResponseValue;
7322 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
7324 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7325 if(!isWasmInitialized) {
7326 throw new Error("initializeWasm() must be awaited first!");
7328 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
7329 // debug statements here
7331 // uintptr_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7333 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7334 if(!isWasmInitialized) {
7335 throw new Error("initializeWasm() must be awaited first!");
7337 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7338 return nativeResponseValue;
7340 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7342 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7343 if(!isWasmInitialized) {
7344 throw new Error("initializeWasm() must be awaited first!");
7346 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
7347 return nativeResponseValue;
7349 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
7351 export function CResult_TrustedClosingTransactionNoneZ_ok(o: number): number {
7352 if(!isWasmInitialized) {
7353 throw new Error("initializeWasm() must be awaited first!");
7355 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
7356 return nativeResponseValue;
7358 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
7360 export function CResult_TrustedClosingTransactionNoneZ_err(): number {
7361 if(!isWasmInitialized) {
7362 throw new Error("initializeWasm() must be awaited first!");
7364 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
7365 return nativeResponseValue;
7367 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
7369 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: number): boolean {
7370 if(!isWasmInitialized) {
7371 throw new Error("initializeWasm() must be awaited first!");
7373 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
7374 return nativeResponseValue;
7376 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
7378 export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
7379 if(!isWasmInitialized) {
7380 throw new Error("initializeWasm() must be awaited first!");
7382 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
7383 // debug statements here
7385 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
7387 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: number): number {
7388 if(!isWasmInitialized) {
7389 throw new Error("initializeWasm() must be awaited first!");
7391 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
7392 return nativeResponseValue;
7394 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7396 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: number): number {
7397 if(!isWasmInitialized) {
7398 throw new Error("initializeWasm() must be awaited first!");
7400 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
7401 return nativeResponseValue;
7403 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7405 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7406 if(!isWasmInitialized) {
7407 throw new Error("initializeWasm() must be awaited first!");
7409 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
7410 return nativeResponseValue;
7412 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
7414 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: number): void {
7415 if(!isWasmInitialized) {
7416 throw new Error("initializeWasm() must be awaited first!");
7418 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
7419 // debug statements here
7421 // uintptr_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7423 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7424 if(!isWasmInitialized) {
7425 throw new Error("initializeWasm() must be awaited first!");
7427 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7428 return nativeResponseValue;
7430 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7432 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7433 if(!isWasmInitialized) {
7434 throw new Error("initializeWasm() must be awaited first!");
7436 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
7437 return nativeResponseValue;
7439 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
7441 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
7442 if(!isWasmInitialized) {
7443 throw new Error("initializeWasm() must be awaited first!");
7445 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
7446 return nativeResponseValue;
7448 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
7450 export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
7451 if(!isWasmInitialized) {
7452 throw new Error("initializeWasm() must be awaited first!");
7454 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
7455 return nativeResponseValue;
7457 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
7459 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: number): boolean {
7460 if(!isWasmInitialized) {
7461 throw new Error("initializeWasm() must be awaited first!");
7463 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
7464 return nativeResponseValue;
7466 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
7468 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
7469 if(!isWasmInitialized) {
7470 throw new Error("initializeWasm() must be awaited first!");
7472 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
7473 // debug statements here
7475 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
7477 export function CResult_CVec_SignatureZNoneZ_ok(o: number): number {
7478 if(!isWasmInitialized) {
7479 throw new Error("initializeWasm() must be awaited first!");
7481 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
7482 return nativeResponseValue;
7484 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
7486 export function CResult_CVec_SignatureZNoneZ_err(): number {
7487 if(!isWasmInitialized) {
7488 throw new Error("initializeWasm() must be awaited first!");
7490 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
7491 return nativeResponseValue;
7493 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
7495 export function CResult_CVec_SignatureZNoneZ_is_ok(o: number): boolean {
7496 if(!isWasmInitialized) {
7497 throw new Error("initializeWasm() must be awaited first!");
7499 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
7500 return nativeResponseValue;
7502 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
7504 export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
7505 if(!isWasmInitialized) {
7506 throw new Error("initializeWasm() must be awaited first!");
7508 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
7509 // debug statements here
7511 // uintptr_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
7513 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: number): number {
7514 if(!isWasmInitialized) {
7515 throw new Error("initializeWasm() must be awaited first!");
7517 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
7518 return nativeResponseValue;
7520 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
7522 export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
7523 if(!isWasmInitialized) {
7524 throw new Error("initializeWasm() must be awaited first!");
7526 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
7527 return nativeResponseValue;
7529 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
7531 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: number): number {
7532 if(!isWasmInitialized) {
7533 throw new Error("initializeWasm() must be awaited first!");
7535 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
7536 return nativeResponseValue;
7538 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
7540 export function CResult_ShutdownScriptDecodeErrorZ_err(e: number): number {
7541 if(!isWasmInitialized) {
7542 throw new Error("initializeWasm() must be awaited first!");
7544 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
7545 return nativeResponseValue;
7547 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
7549 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: number): boolean {
7550 if(!isWasmInitialized) {
7551 throw new Error("initializeWasm() must be awaited first!");
7553 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
7554 return nativeResponseValue;
7556 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
7558 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
7559 if(!isWasmInitialized) {
7560 throw new Error("initializeWasm() must be awaited first!");
7562 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
7563 // debug statements here
7565 // uintptr_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
7567 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: number): number {
7568 if(!isWasmInitialized) {
7569 throw new Error("initializeWasm() must be awaited first!");
7571 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
7572 return nativeResponseValue;
7574 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
7576 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
7577 if(!isWasmInitialized) {
7578 throw new Error("initializeWasm() must be awaited first!");
7580 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
7581 return nativeResponseValue;
7583 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
7585 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: number): number {
7586 if(!isWasmInitialized) {
7587 throw new Error("initializeWasm() must be awaited first!");
7589 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
7590 return nativeResponseValue;
7592 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
7594 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: number): number {
7595 if(!isWasmInitialized) {
7596 throw new Error("initializeWasm() must be awaited first!");
7598 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
7599 return nativeResponseValue;
7601 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
7603 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: number): boolean {
7604 if(!isWasmInitialized) {
7605 throw new Error("initializeWasm() must be awaited first!");
7607 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
7608 return nativeResponseValue;
7610 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
7612 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
7613 if(!isWasmInitialized) {
7614 throw new Error("initializeWasm() must be awaited first!");
7616 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
7617 // debug statements here
7619 // uintptr_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
7621 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: number): number {
7622 if(!isWasmInitialized) {
7623 throw new Error("initializeWasm() must be awaited first!");
7625 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
7626 return nativeResponseValue;
7628 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
7630 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: number): number {
7631 if(!isWasmInitialized) {
7632 throw new Error("initializeWasm() must be awaited first!");
7634 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
7635 return nativeResponseValue;
7637 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
7639 export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
7640 if(!isWasmInitialized) {
7641 throw new Error("initializeWasm() must be awaited first!");
7643 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
7644 return nativeResponseValue;
7646 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
7648 export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
7649 if(!isWasmInitialized) {
7650 throw new Error("initializeWasm() must be awaited first!");
7652 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
7653 return nativeResponseValue;
7655 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
7657 export function CResult_RouteHopDecodeErrorZ_is_ok(o: number): boolean {
7658 if(!isWasmInitialized) {
7659 throw new Error("initializeWasm() must be awaited first!");
7661 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
7662 return nativeResponseValue;
7664 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
7666 export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
7667 if(!isWasmInitialized) {
7668 throw new Error("initializeWasm() must be awaited first!");
7670 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
7671 // debug statements here
7673 // uintptr_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
7675 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: number): number {
7676 if(!isWasmInitialized) {
7677 throw new Error("initializeWasm() must be awaited first!");
7679 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
7680 return nativeResponseValue;
7682 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
7684 export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
7685 if(!isWasmInitialized) {
7686 throw new Error("initializeWasm() must be awaited first!");
7688 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
7689 return nativeResponseValue;
7691 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
7693 export function CVec_RouteHopZ_free(_res: number): void {
7694 if(!isWasmInitialized) {
7695 throw new Error("initializeWasm() must be awaited first!");
7697 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
7698 // debug statements here
7700 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
7702 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
7703 if(!isWasmInitialized) {
7704 throw new Error("initializeWasm() must be awaited first!");
7706 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
7707 // debug statements here
7709 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
7711 export function CResult_RouteDecodeErrorZ_ok(o: number): number {
7712 if(!isWasmInitialized) {
7713 throw new Error("initializeWasm() must be awaited first!");
7715 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
7716 return nativeResponseValue;
7718 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
7720 export function CResult_RouteDecodeErrorZ_err(e: number): number {
7721 if(!isWasmInitialized) {
7722 throw new Error("initializeWasm() must be awaited first!");
7724 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
7725 return nativeResponseValue;
7727 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
7729 export function CResult_RouteDecodeErrorZ_is_ok(o: number): boolean {
7730 if(!isWasmInitialized) {
7731 throw new Error("initializeWasm() must be awaited first!");
7733 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
7734 return nativeResponseValue;
7736 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
7738 export function CResult_RouteDecodeErrorZ_free(_res: number): void {
7739 if(!isWasmInitialized) {
7740 throw new Error("initializeWasm() must be awaited first!");
7742 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
7743 // debug statements here
7745 // uintptr_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
7747 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: number): number {
7748 if(!isWasmInitialized) {
7749 throw new Error("initializeWasm() must be awaited first!");
7751 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
7752 return nativeResponseValue;
7754 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
7756 export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
7757 if(!isWasmInitialized) {
7758 throw new Error("initializeWasm() must be awaited first!");
7760 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
7761 return nativeResponseValue;
7763 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
7765 export function CResult_RouteParametersDecodeErrorZ_ok(o: number): number {
7766 if(!isWasmInitialized) {
7767 throw new Error("initializeWasm() must be awaited first!");
7769 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
7770 return nativeResponseValue;
7772 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
7774 export function CResult_RouteParametersDecodeErrorZ_err(e: number): number {
7775 if(!isWasmInitialized) {
7776 throw new Error("initializeWasm() must be awaited first!");
7778 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
7779 return nativeResponseValue;
7781 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
7783 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: number): boolean {
7784 if(!isWasmInitialized) {
7785 throw new Error("initializeWasm() must be awaited first!");
7787 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
7788 return nativeResponseValue;
7790 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
7792 export function CResult_RouteParametersDecodeErrorZ_free(_res: number): void {
7793 if(!isWasmInitialized) {
7794 throw new Error("initializeWasm() must be awaited first!");
7796 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
7797 // debug statements here
7799 // uintptr_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
7801 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: number): number {
7802 if(!isWasmInitialized) {
7803 throw new Error("initializeWasm() must be awaited first!");
7805 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
7806 return nativeResponseValue;
7808 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
7810 export function CResult_RouteParametersDecodeErrorZ_clone(orig: number): number {
7811 if(!isWasmInitialized) {
7812 throw new Error("initializeWasm() must be awaited first!");
7814 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
7815 return nativeResponseValue;
7817 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
7819 export function CVec_RouteHintZ_free(_res: number): void {
7820 if(!isWasmInitialized) {
7821 throw new Error("initializeWasm() must be awaited first!");
7823 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
7824 // debug statements here
7826 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
7828 export function COption_u64Z_some(o: bigint): number {
7829 if(!isWasmInitialized) {
7830 throw new Error("initializeWasm() must be awaited first!");
7832 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
7833 return nativeResponseValue;
7835 // struct LDKCOption_u64Z COption_u64Z_none(void);
7837 export function COption_u64Z_none(): number {
7838 if(!isWasmInitialized) {
7839 throw new Error("initializeWasm() must be awaited first!");
7841 const nativeResponseValue = wasm.TS_COption_u64Z_none();
7842 return nativeResponseValue;
7844 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
7846 export function COption_u64Z_free(_res: number): void {
7847 if(!isWasmInitialized) {
7848 throw new Error("initializeWasm() must be awaited first!");
7850 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
7851 // debug statements here
7853 // uintptr_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
7855 export function COption_u64Z_clone_ptr(arg: number): number {
7856 if(!isWasmInitialized) {
7857 throw new Error("initializeWasm() must be awaited first!");
7859 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
7860 return nativeResponseValue;
7862 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
7864 export function COption_u64Z_clone(orig: number): number {
7865 if(!isWasmInitialized) {
7866 throw new Error("initializeWasm() must be awaited first!");
7868 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
7869 return nativeResponseValue;
7871 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
7873 export function CResult_PaymentParametersDecodeErrorZ_ok(o: number): number {
7874 if(!isWasmInitialized) {
7875 throw new Error("initializeWasm() must be awaited first!");
7877 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
7878 return nativeResponseValue;
7880 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
7882 export function CResult_PaymentParametersDecodeErrorZ_err(e: number): number {
7883 if(!isWasmInitialized) {
7884 throw new Error("initializeWasm() must be awaited first!");
7886 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
7887 return nativeResponseValue;
7889 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
7891 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: number): boolean {
7892 if(!isWasmInitialized) {
7893 throw new Error("initializeWasm() must be awaited first!");
7895 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
7896 return nativeResponseValue;
7898 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
7900 export function CResult_PaymentParametersDecodeErrorZ_free(_res: number): void {
7901 if(!isWasmInitialized) {
7902 throw new Error("initializeWasm() must be awaited first!");
7904 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
7905 // debug statements here
7907 // uintptr_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
7909 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: number): number {
7910 if(!isWasmInitialized) {
7911 throw new Error("initializeWasm() must be awaited first!");
7913 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
7914 return nativeResponseValue;
7916 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
7918 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: number): number {
7919 if(!isWasmInitialized) {
7920 throw new Error("initializeWasm() must be awaited first!");
7922 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
7923 return nativeResponseValue;
7925 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
7927 export function CVec_RouteHintHopZ_free(_res: number): void {
7928 if(!isWasmInitialized) {
7929 throw new Error("initializeWasm() must be awaited first!");
7931 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
7932 // debug statements here
7934 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
7936 export function CResult_RouteHintDecodeErrorZ_ok(o: number): number {
7937 if(!isWasmInitialized) {
7938 throw new Error("initializeWasm() must be awaited first!");
7940 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
7941 return nativeResponseValue;
7943 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
7945 export function CResult_RouteHintDecodeErrorZ_err(e: number): number {
7946 if(!isWasmInitialized) {
7947 throw new Error("initializeWasm() must be awaited first!");
7949 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
7950 return nativeResponseValue;
7952 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
7954 export function CResult_RouteHintDecodeErrorZ_is_ok(o: number): boolean {
7955 if(!isWasmInitialized) {
7956 throw new Error("initializeWasm() must be awaited first!");
7958 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
7959 return nativeResponseValue;
7961 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
7963 export function CResult_RouteHintDecodeErrorZ_free(_res: number): void {
7964 if(!isWasmInitialized) {
7965 throw new Error("initializeWasm() must be awaited first!");
7967 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
7968 // debug statements here
7970 // uintptr_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
7972 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: number): number {
7973 if(!isWasmInitialized) {
7974 throw new Error("initializeWasm() must be awaited first!");
7976 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
7977 return nativeResponseValue;
7979 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
7981 export function CResult_RouteHintDecodeErrorZ_clone(orig: number): number {
7982 if(!isWasmInitialized) {
7983 throw new Error("initializeWasm() must be awaited first!");
7985 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
7986 return nativeResponseValue;
7988 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
7990 export function CResult_RouteHintHopDecodeErrorZ_ok(o: number): number {
7991 if(!isWasmInitialized) {
7992 throw new Error("initializeWasm() must be awaited first!");
7994 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
7995 return nativeResponseValue;
7997 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
7999 export function CResult_RouteHintHopDecodeErrorZ_err(e: number): number {
8000 if(!isWasmInitialized) {
8001 throw new Error("initializeWasm() must be awaited first!");
8003 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
8004 return nativeResponseValue;
8006 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
8008 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: number): boolean {
8009 if(!isWasmInitialized) {
8010 throw new Error("initializeWasm() must be awaited first!");
8012 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
8013 return nativeResponseValue;
8015 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
8017 export function CResult_RouteHintHopDecodeErrorZ_free(_res: number): void {
8018 if(!isWasmInitialized) {
8019 throw new Error("initializeWasm() must be awaited first!");
8021 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
8022 // debug statements here
8024 // uintptr_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
8026 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: number): number {
8027 if(!isWasmInitialized) {
8028 throw new Error("initializeWasm() must be awaited first!");
8030 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
8031 return nativeResponseValue;
8033 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
8035 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: number): number {
8036 if(!isWasmInitialized) {
8037 throw new Error("initializeWasm() must be awaited first!");
8039 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
8040 return nativeResponseValue;
8042 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
8044 export function CVec_ChannelDetailsZ_free(_res: number): void {
8045 if(!isWasmInitialized) {
8046 throw new Error("initializeWasm() must be awaited first!");
8048 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
8049 // debug statements here
8051 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
8053 export function CResult_RouteLightningErrorZ_ok(o: number): number {
8054 if(!isWasmInitialized) {
8055 throw new Error("initializeWasm() must be awaited first!");
8057 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
8058 return nativeResponseValue;
8060 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
8062 export function CResult_RouteLightningErrorZ_err(e: number): number {
8063 if(!isWasmInitialized) {
8064 throw new Error("initializeWasm() must be awaited first!");
8066 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
8067 return nativeResponseValue;
8069 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
8071 export function CResult_RouteLightningErrorZ_is_ok(o: number): boolean {
8072 if(!isWasmInitialized) {
8073 throw new Error("initializeWasm() must be awaited first!");
8075 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
8076 return nativeResponseValue;
8078 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
8080 export function CResult_RouteLightningErrorZ_free(_res: number): void {
8081 if(!isWasmInitialized) {
8082 throw new Error("initializeWasm() must be awaited first!");
8084 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
8085 // debug statements here
8087 // uintptr_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
8089 export function CResult_RouteLightningErrorZ_clone_ptr(arg: number): number {
8090 if(!isWasmInitialized) {
8091 throw new Error("initializeWasm() must be awaited first!");
8093 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
8094 return nativeResponseValue;
8096 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
8098 export function CResult_RouteLightningErrorZ_clone(orig: number): number {
8099 if(!isWasmInitialized) {
8100 throw new Error("initializeWasm() must be awaited first!");
8102 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
8103 return nativeResponseValue;
8105 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
8107 export function CVec_PublicKeyZ_free(_res: number): void {
8108 if(!isWasmInitialized) {
8109 throw new Error("initializeWasm() must be awaited first!");
8111 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
8112 // debug statements here
8114 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
8116 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: number): number {
8117 if(!isWasmInitialized) {
8118 throw new Error("initializeWasm() must be awaited first!");
8120 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
8121 return nativeResponseValue;
8123 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
8125 export function CResult_PaymentPurposeDecodeErrorZ_err(e: number): number {
8126 if(!isWasmInitialized) {
8127 throw new Error("initializeWasm() must be awaited first!");
8129 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
8130 return nativeResponseValue;
8132 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
8134 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: number): boolean {
8135 if(!isWasmInitialized) {
8136 throw new Error("initializeWasm() must be awaited first!");
8138 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
8139 return nativeResponseValue;
8141 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
8143 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: number): void {
8144 if(!isWasmInitialized) {
8145 throw new Error("initializeWasm() must be awaited first!");
8147 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
8148 // debug statements here
8150 // uintptr_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
8152 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: number): number {
8153 if(!isWasmInitialized) {
8154 throw new Error("initializeWasm() must be awaited first!");
8156 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
8157 return nativeResponseValue;
8159 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
8161 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: number): number {
8162 if(!isWasmInitialized) {
8163 throw new Error("initializeWasm() must be awaited first!");
8165 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
8166 return nativeResponseValue;
8168 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
8170 export function COption_ClosureReasonZ_some(o: number): number {
8171 if(!isWasmInitialized) {
8172 throw new Error("initializeWasm() must be awaited first!");
8174 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
8175 return nativeResponseValue;
8177 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
8179 export function COption_ClosureReasonZ_none(): number {
8180 if(!isWasmInitialized) {
8181 throw new Error("initializeWasm() must be awaited first!");
8183 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
8184 return nativeResponseValue;
8186 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
8188 export function COption_ClosureReasonZ_free(_res: number): void {
8189 if(!isWasmInitialized) {
8190 throw new Error("initializeWasm() must be awaited first!");
8192 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
8193 // debug statements here
8195 // uintptr_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
8197 export function COption_ClosureReasonZ_clone_ptr(arg: number): number {
8198 if(!isWasmInitialized) {
8199 throw new Error("initializeWasm() must be awaited first!");
8201 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
8202 return nativeResponseValue;
8204 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
8206 export function COption_ClosureReasonZ_clone(orig: number): number {
8207 if(!isWasmInitialized) {
8208 throw new Error("initializeWasm() must be awaited first!");
8210 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
8211 return nativeResponseValue;
8213 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
8215 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: number): number {
8216 if(!isWasmInitialized) {
8217 throw new Error("initializeWasm() must be awaited first!");
8219 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
8220 return nativeResponseValue;
8222 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
8224 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: number): number {
8225 if(!isWasmInitialized) {
8226 throw new Error("initializeWasm() must be awaited first!");
8228 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
8229 return nativeResponseValue;
8231 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
8233 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: number): boolean {
8234 if(!isWasmInitialized) {
8235 throw new Error("initializeWasm() must be awaited first!");
8237 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
8238 return nativeResponseValue;
8240 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
8242 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: number): void {
8243 if(!isWasmInitialized) {
8244 throw new Error("initializeWasm() must be awaited first!");
8246 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
8247 // debug statements here
8249 // uintptr_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
8251 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: number): number {
8252 if(!isWasmInitialized) {
8253 throw new Error("initializeWasm() must be awaited first!");
8255 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
8256 return nativeResponseValue;
8258 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
8260 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: number): number {
8261 if(!isWasmInitialized) {
8262 throw new Error("initializeWasm() must be awaited first!");
8264 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
8265 return nativeResponseValue;
8267 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
8269 export function COption_NetworkUpdateZ_some(o: number): number {
8270 if(!isWasmInitialized) {
8271 throw new Error("initializeWasm() must be awaited first!");
8273 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
8274 return nativeResponseValue;
8276 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
8278 export function COption_NetworkUpdateZ_none(): number {
8279 if(!isWasmInitialized) {
8280 throw new Error("initializeWasm() must be awaited first!");
8282 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
8283 return nativeResponseValue;
8285 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
8287 export function COption_NetworkUpdateZ_free(_res: number): void {
8288 if(!isWasmInitialized) {
8289 throw new Error("initializeWasm() must be awaited first!");
8291 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
8292 // debug statements here
8294 // uintptr_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
8296 export function COption_NetworkUpdateZ_clone_ptr(arg: number): number {
8297 if(!isWasmInitialized) {
8298 throw new Error("initializeWasm() must be awaited first!");
8300 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
8301 return nativeResponseValue;
8303 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
8305 export function COption_NetworkUpdateZ_clone(orig: number): number {
8306 if(!isWasmInitialized) {
8307 throw new Error("initializeWasm() must be awaited first!");
8309 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
8310 return nativeResponseValue;
8312 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
8314 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
8315 if(!isWasmInitialized) {
8316 throw new Error("initializeWasm() must be awaited first!");
8318 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
8319 // debug statements here
8321 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
8323 export function COption_EventZ_some(o: number): number {
8324 if(!isWasmInitialized) {
8325 throw new Error("initializeWasm() must be awaited first!");
8327 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
8328 return nativeResponseValue;
8330 // struct LDKCOption_EventZ COption_EventZ_none(void);
8332 export function COption_EventZ_none(): number {
8333 if(!isWasmInitialized) {
8334 throw new Error("initializeWasm() must be awaited first!");
8336 const nativeResponseValue = wasm.TS_COption_EventZ_none();
8337 return nativeResponseValue;
8339 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
8341 export function COption_EventZ_free(_res: number): void {
8342 if(!isWasmInitialized) {
8343 throw new Error("initializeWasm() must be awaited first!");
8345 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
8346 // debug statements here
8348 // uintptr_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
8350 export function COption_EventZ_clone_ptr(arg: number): number {
8351 if(!isWasmInitialized) {
8352 throw new Error("initializeWasm() must be awaited first!");
8354 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
8355 return nativeResponseValue;
8357 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
8359 export function COption_EventZ_clone(orig: number): number {
8360 if(!isWasmInitialized) {
8361 throw new Error("initializeWasm() must be awaited first!");
8363 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
8364 return nativeResponseValue;
8366 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
8368 export function CResult_COption_EventZDecodeErrorZ_ok(o: number): number {
8369 if(!isWasmInitialized) {
8370 throw new Error("initializeWasm() must be awaited first!");
8372 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
8373 return nativeResponseValue;
8375 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
8377 export function CResult_COption_EventZDecodeErrorZ_err(e: number): number {
8378 if(!isWasmInitialized) {
8379 throw new Error("initializeWasm() must be awaited first!");
8381 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
8382 return nativeResponseValue;
8384 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
8386 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: number): boolean {
8387 if(!isWasmInitialized) {
8388 throw new Error("initializeWasm() must be awaited first!");
8390 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
8391 return nativeResponseValue;
8393 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
8395 export function CResult_COption_EventZDecodeErrorZ_free(_res: number): void {
8396 if(!isWasmInitialized) {
8397 throw new Error("initializeWasm() must be awaited first!");
8399 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
8400 // debug statements here
8402 // uintptr_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
8404 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: number): number {
8405 if(!isWasmInitialized) {
8406 throw new Error("initializeWasm() must be awaited first!");
8408 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
8409 return nativeResponseValue;
8411 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
8413 export function CResult_COption_EventZDecodeErrorZ_clone(orig: number): number {
8414 if(!isWasmInitialized) {
8415 throw new Error("initializeWasm() must be awaited first!");
8417 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
8418 return nativeResponseValue;
8420 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
8422 export function CVec_MessageSendEventZ_free(_res: number): void {
8423 if(!isWasmInitialized) {
8424 throw new Error("initializeWasm() must be awaited first!");
8426 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
8427 // debug statements here
8429 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
8431 export function CResult_TxOutAccessErrorZ_ok(o: number): number {
8432 if(!isWasmInitialized) {
8433 throw new Error("initializeWasm() must be awaited first!");
8435 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
8436 return nativeResponseValue;
8438 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
8440 export function CResult_TxOutAccessErrorZ_err(e: AccessError): number {
8441 if(!isWasmInitialized) {
8442 throw new Error("initializeWasm() must be awaited first!");
8444 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
8445 return nativeResponseValue;
8447 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
8449 export function CResult_TxOutAccessErrorZ_is_ok(o: number): boolean {
8450 if(!isWasmInitialized) {
8451 throw new Error("initializeWasm() must be awaited first!");
8453 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
8454 return nativeResponseValue;
8456 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
8458 export function CResult_TxOutAccessErrorZ_free(_res: number): void {
8459 if(!isWasmInitialized) {
8460 throw new Error("initializeWasm() must be awaited first!");
8462 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
8463 // debug statements here
8465 // uintptr_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
8467 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: number): number {
8468 if(!isWasmInitialized) {
8469 throw new Error("initializeWasm() must be awaited first!");
8471 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
8472 return nativeResponseValue;
8474 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
8476 export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
8477 if(!isWasmInitialized) {
8478 throw new Error("initializeWasm() must be awaited first!");
8480 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
8481 return nativeResponseValue;
8483 // uintptr_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
8485 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: number): number {
8486 if(!isWasmInitialized) {
8487 throw new Error("initializeWasm() must be awaited first!");
8489 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
8490 return nativeResponseValue;
8492 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
8494 export function C2Tuple_usizeTransactionZ_clone(orig: number): number {
8495 if(!isWasmInitialized) {
8496 throw new Error("initializeWasm() must be awaited first!");
8498 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
8499 return nativeResponseValue;
8501 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
8503 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): number {
8504 if(!isWasmInitialized) {
8505 throw new Error("initializeWasm() must be awaited first!");
8507 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
8508 return nativeResponseValue;
8510 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
8512 export function C2Tuple_usizeTransactionZ_free(_res: number): void {
8513 if(!isWasmInitialized) {
8514 throw new Error("initializeWasm() must be awaited first!");
8516 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
8517 // debug statements here
8519 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
8521 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8522 if(!isWasmInitialized) {
8523 throw new Error("initializeWasm() must be awaited first!");
8525 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
8526 // debug statements here
8528 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
8530 export function CVec_TxidZ_free(_res: number): void {
8531 if(!isWasmInitialized) {
8532 throw new Error("initializeWasm() must be awaited first!");
8534 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
8535 // debug statements here
8537 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
8539 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
8540 if(!isWasmInitialized) {
8541 throw new Error("initializeWasm() must be awaited first!");
8543 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
8544 return nativeResponseValue;
8546 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
8548 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): number {
8549 if(!isWasmInitialized) {
8550 throw new Error("initializeWasm() must be awaited first!");
8552 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
8553 return nativeResponseValue;
8555 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
8557 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: number): boolean {
8558 if(!isWasmInitialized) {
8559 throw new Error("initializeWasm() must be awaited first!");
8561 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
8562 return nativeResponseValue;
8564 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
8566 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
8567 if(!isWasmInitialized) {
8568 throw new Error("initializeWasm() must be awaited first!");
8570 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
8571 // debug statements here
8573 // uintptr_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
8575 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: number): number {
8576 if(!isWasmInitialized) {
8577 throw new Error("initializeWasm() must be awaited first!");
8579 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
8580 return nativeResponseValue;
8582 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
8584 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
8585 if(!isWasmInitialized) {
8586 throw new Error("initializeWasm() must be awaited first!");
8588 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
8589 return nativeResponseValue;
8591 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
8593 export function CVec_MonitorEventZ_free(_res: number): void {
8594 if(!isWasmInitialized) {
8595 throw new Error("initializeWasm() must be awaited first!");
8597 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
8598 // debug statements here
8600 // uintptr_t C2Tuple_OutPointCVec_MonitorEventZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR arg);
8602 export function C2Tuple_OutPointCVec_MonitorEventZZ_clone_ptr(arg: number): number {
8603 if(!isWasmInitialized) {
8604 throw new Error("initializeWasm() must be awaited first!");
8606 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_clone_ptr(arg);
8607 return nativeResponseValue;
8609 // struct LDKC2Tuple_OutPointCVec_MonitorEventZZ C2Tuple_OutPointCVec_MonitorEventZZ_clone(const struct LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR orig);
8611 export function C2Tuple_OutPointCVec_MonitorEventZZ_clone(orig: number): number {
8612 if(!isWasmInitialized) {
8613 throw new Error("initializeWasm() must be awaited first!");
8615 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_clone(orig);
8616 return nativeResponseValue;
8618 // struct LDKC2Tuple_OutPointCVec_MonitorEventZZ C2Tuple_OutPointCVec_MonitorEventZZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b);
8620 export function C2Tuple_OutPointCVec_MonitorEventZZ_new(a: number, b: number): number {
8621 if(!isWasmInitialized) {
8622 throw new Error("initializeWasm() must be awaited first!");
8624 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_new(a, b);
8625 return nativeResponseValue;
8627 // void C2Tuple_OutPointCVec_MonitorEventZZ_free(struct LDKC2Tuple_OutPointCVec_MonitorEventZZ _res);
8629 export function C2Tuple_OutPointCVec_MonitorEventZZ_free(_res: number): void {
8630 if(!isWasmInitialized) {
8631 throw new Error("initializeWasm() must be awaited first!");
8633 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_free(_res);
8634 // debug statements here
8636 // void CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(struct LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ _res);
8638 export function CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(_res: number): void {
8639 if(!isWasmInitialized) {
8640 throw new Error("initializeWasm() must be awaited first!");
8642 const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(_res);
8643 // debug statements here
8645 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
8647 export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
8648 if(!isWasmInitialized) {
8649 throw new Error("initializeWasm() must be awaited first!");
8651 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_some(o);
8652 return nativeResponseValue;
8654 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
8656 export function COption_C2Tuple_usizeTransactionZZ_none(): number {
8657 if(!isWasmInitialized) {
8658 throw new Error("initializeWasm() must be awaited first!");
8660 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_none();
8661 return nativeResponseValue;
8663 // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
8665 export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8666 if(!isWasmInitialized) {
8667 throw new Error("initializeWasm() must be awaited first!");
8669 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_free(_res);
8670 // debug statements here
8672 // uintptr_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
8674 export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: number): number {
8675 if(!isWasmInitialized) {
8676 throw new Error("initializeWasm() must be awaited first!");
8678 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
8679 return nativeResponseValue;
8681 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
8683 export function COption_C2Tuple_usizeTransactionZZ_clone(orig: number): number {
8684 if(!isWasmInitialized) {
8685 throw new Error("initializeWasm() must be awaited first!");
8687 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone(orig);
8688 return nativeResponseValue;
8690 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
8692 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: number): number {
8693 if(!isWasmInitialized) {
8694 throw new Error("initializeWasm() must be awaited first!");
8696 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
8697 return nativeResponseValue;
8699 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
8701 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: number): number {
8702 if(!isWasmInitialized) {
8703 throw new Error("initializeWasm() must be awaited first!");
8705 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
8706 return nativeResponseValue;
8708 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
8710 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: number): boolean {
8711 if(!isWasmInitialized) {
8712 throw new Error("initializeWasm() must be awaited first!");
8714 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
8715 return nativeResponseValue;
8717 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
8719 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: number): void {
8720 if(!isWasmInitialized) {
8721 throw new Error("initializeWasm() must be awaited first!");
8723 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
8724 // debug statements here
8726 // uintptr_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
8728 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: number): number {
8729 if(!isWasmInitialized) {
8730 throw new Error("initializeWasm() must be awaited first!");
8732 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
8733 return nativeResponseValue;
8735 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
8737 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: number): number {
8738 if(!isWasmInitialized) {
8739 throw new Error("initializeWasm() must be awaited first!");
8741 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
8742 return nativeResponseValue;
8744 // uintptr_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
8746 export function C2Tuple_u64u64Z_clone_ptr(arg: number): number {
8747 if(!isWasmInitialized) {
8748 throw new Error("initializeWasm() must be awaited first!");
8750 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
8751 return nativeResponseValue;
8753 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
8755 export function C2Tuple_u64u64Z_clone(orig: number): number {
8756 if(!isWasmInitialized) {
8757 throw new Error("initializeWasm() must be awaited first!");
8759 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
8760 return nativeResponseValue;
8762 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
8764 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): number {
8765 if(!isWasmInitialized) {
8766 throw new Error("initializeWasm() must be awaited first!");
8768 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
8769 return nativeResponseValue;
8771 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
8773 export function C2Tuple_u64u64Z_free(_res: number): void {
8774 if(!isWasmInitialized) {
8775 throw new Error("initializeWasm() must be awaited first!");
8777 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
8778 // debug statements here
8780 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
8782 export function COption_C2Tuple_u64u64ZZ_some(o: number): number {
8783 if(!isWasmInitialized) {
8784 throw new Error("initializeWasm() must be awaited first!");
8786 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
8787 return nativeResponseValue;
8789 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
8791 export function COption_C2Tuple_u64u64ZZ_none(): number {
8792 if(!isWasmInitialized) {
8793 throw new Error("initializeWasm() must be awaited first!");
8795 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
8796 return nativeResponseValue;
8798 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
8800 export function COption_C2Tuple_u64u64ZZ_free(_res: number): void {
8801 if(!isWasmInitialized) {
8802 throw new Error("initializeWasm() must be awaited first!");
8804 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
8805 // debug statements here
8807 // uintptr_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
8809 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: number): number {
8810 if(!isWasmInitialized) {
8811 throw new Error("initializeWasm() must be awaited first!");
8813 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
8814 return nativeResponseValue;
8816 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
8818 export function COption_C2Tuple_u64u64ZZ_clone(orig: number): number {
8819 if(!isWasmInitialized) {
8820 throw new Error("initializeWasm() must be awaited first!");
8822 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
8823 return nativeResponseValue;
8825 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
8827 export function CVec_NodeIdZ_free(_res: number): void {
8828 if(!isWasmInitialized) {
8829 throw new Error("initializeWasm() must be awaited first!");
8831 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
8832 // debug statements here
8834 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
8836 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: number): number {
8837 if(!isWasmInitialized) {
8838 throw new Error("initializeWasm() must be awaited first!");
8840 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
8841 return nativeResponseValue;
8843 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
8845 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: number): number {
8846 if(!isWasmInitialized) {
8847 throw new Error("initializeWasm() must be awaited first!");
8849 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
8850 return nativeResponseValue;
8852 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
8854 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: number): boolean {
8855 if(!isWasmInitialized) {
8856 throw new Error("initializeWasm() must be awaited first!");
8858 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
8859 return nativeResponseValue;
8861 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
8863 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: number): void {
8864 if(!isWasmInitialized) {
8865 throw new Error("initializeWasm() must be awaited first!");
8867 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
8868 // debug statements here
8870 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
8872 export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
8873 if(!isWasmInitialized) {
8874 throw new Error("initializeWasm() must be awaited first!");
8876 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
8877 return nativeResponseValue;
8879 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8881 export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
8882 if(!isWasmInitialized) {
8883 throw new Error("initializeWasm() must be awaited first!");
8885 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
8886 return nativeResponseValue;
8888 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
8890 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8891 if(!isWasmInitialized) {
8892 throw new Error("initializeWasm() must be awaited first!");
8894 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
8895 return nativeResponseValue;
8897 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
8899 export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
8900 if(!isWasmInitialized) {
8901 throw new Error("initializeWasm() must be awaited first!");
8903 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
8904 // debug statements here
8906 // uintptr_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
8908 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8909 if(!isWasmInitialized) {
8910 throw new Error("initializeWasm() must be awaited first!");
8912 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
8913 return nativeResponseValue;
8915 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
8917 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: number): number {
8918 if(!isWasmInitialized) {
8919 throw new Error("initializeWasm() must be awaited first!");
8921 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
8922 return nativeResponseValue;
8924 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
8926 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
8927 if(!isWasmInitialized) {
8928 throw new Error("initializeWasm() must be awaited first!");
8930 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
8931 return nativeResponseValue;
8933 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8935 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
8936 if(!isWasmInitialized) {
8937 throw new Error("initializeWasm() must be awaited first!");
8939 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
8940 return nativeResponseValue;
8942 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
8944 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8945 if(!isWasmInitialized) {
8946 throw new Error("initializeWasm() must be awaited first!");
8948 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
8949 return nativeResponseValue;
8951 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
8953 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
8954 if(!isWasmInitialized) {
8955 throw new Error("initializeWasm() must be awaited first!");
8957 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
8958 // debug statements here
8960 // uintptr_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
8962 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8963 if(!isWasmInitialized) {
8964 throw new Error("initializeWasm() must be awaited first!");
8966 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
8967 return nativeResponseValue;
8969 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
8971 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: number): number {
8972 if(!isWasmInitialized) {
8973 throw new Error("initializeWasm() must be awaited first!");
8975 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
8976 return nativeResponseValue;
8978 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
8980 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
8981 if(!isWasmInitialized) {
8982 throw new Error("initializeWasm() must be awaited first!");
8984 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
8985 return nativeResponseValue;
8987 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8989 export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
8990 if(!isWasmInitialized) {
8991 throw new Error("initializeWasm() must be awaited first!");
8993 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
8994 return nativeResponseValue;
8996 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
8998 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8999 if(!isWasmInitialized) {
9000 throw new Error("initializeWasm() must be awaited first!");
9002 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
9003 return nativeResponseValue;
9005 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
9007 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
9008 if(!isWasmInitialized) {
9009 throw new Error("initializeWasm() must be awaited first!");
9011 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
9012 // debug statements here
9014 // uintptr_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
9016 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9017 if(!isWasmInitialized) {
9018 throw new Error("initializeWasm() must be awaited first!");
9020 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
9021 return nativeResponseValue;
9023 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
9025 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: number): number {
9026 if(!isWasmInitialized) {
9027 throw new Error("initializeWasm() must be awaited first!");
9029 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
9030 return nativeResponseValue;
9032 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
9034 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
9035 if(!isWasmInitialized) {
9036 throw new Error("initializeWasm() must be awaited first!");
9038 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
9039 return nativeResponseValue;
9041 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9043 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
9044 if(!isWasmInitialized) {
9045 throw new Error("initializeWasm() must be awaited first!");
9047 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
9048 return nativeResponseValue;
9050 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
9052 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9053 if(!isWasmInitialized) {
9054 throw new Error("initializeWasm() must be awaited first!");
9056 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
9057 return nativeResponseValue;
9059 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
9061 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
9062 if(!isWasmInitialized) {
9063 throw new Error("initializeWasm() must be awaited first!");
9065 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
9066 // debug statements here
9068 // uintptr_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
9070 export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9071 if(!isWasmInitialized) {
9072 throw new Error("initializeWasm() must be awaited first!");
9074 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
9075 return nativeResponseValue;
9077 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
9079 export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: number): number {
9080 if(!isWasmInitialized) {
9081 throw new Error("initializeWasm() must be awaited first!");
9083 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
9084 return nativeResponseValue;
9086 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
9088 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: number): number {
9089 if(!isWasmInitialized) {
9090 throw new Error("initializeWasm() must be awaited first!");
9092 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
9093 return nativeResponseValue;
9095 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9097 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: number): number {
9098 if(!isWasmInitialized) {
9099 throw new Error("initializeWasm() must be awaited first!");
9101 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
9102 return nativeResponseValue;
9104 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
9106 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9107 if(!isWasmInitialized) {
9108 throw new Error("initializeWasm() must be awaited first!");
9110 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
9111 return nativeResponseValue;
9113 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
9115 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: number): void {
9116 if(!isWasmInitialized) {
9117 throw new Error("initializeWasm() must be awaited first!");
9119 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
9120 // debug statements here
9122 // uintptr_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
9124 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9125 if(!isWasmInitialized) {
9126 throw new Error("initializeWasm() must be awaited first!");
9128 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
9129 return nativeResponseValue;
9131 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
9133 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: number): number {
9134 if(!isWasmInitialized) {
9135 throw new Error("initializeWasm() must be awaited first!");
9137 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
9138 return nativeResponseValue;
9140 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
9142 export function CResult_NodeIdDecodeErrorZ_ok(o: number): number {
9143 if(!isWasmInitialized) {
9144 throw new Error("initializeWasm() must be awaited first!");
9146 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
9147 return nativeResponseValue;
9149 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
9151 export function CResult_NodeIdDecodeErrorZ_err(e: number): number {
9152 if(!isWasmInitialized) {
9153 throw new Error("initializeWasm() must be awaited first!");
9155 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
9156 return nativeResponseValue;
9158 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
9160 export function CResult_NodeIdDecodeErrorZ_is_ok(o: number): boolean {
9161 if(!isWasmInitialized) {
9162 throw new Error("initializeWasm() must be awaited first!");
9164 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
9165 return nativeResponseValue;
9167 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
9169 export function CResult_NodeIdDecodeErrorZ_free(_res: number): void {
9170 if(!isWasmInitialized) {
9171 throw new Error("initializeWasm() must be awaited first!");
9173 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
9174 // debug statements here
9176 // uintptr_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
9178 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: number): number {
9179 if(!isWasmInitialized) {
9180 throw new Error("initializeWasm() must be awaited first!");
9182 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
9183 return nativeResponseValue;
9185 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
9187 export function CResult_NodeIdDecodeErrorZ_clone(orig: number): number {
9188 if(!isWasmInitialized) {
9189 throw new Error("initializeWasm() must be awaited first!");
9191 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
9192 return nativeResponseValue;
9194 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
9196 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: number): number {
9197 if(!isWasmInitialized) {
9198 throw new Error("initializeWasm() must be awaited first!");
9200 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
9201 return nativeResponseValue;
9203 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
9205 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: number): number {
9206 if(!isWasmInitialized) {
9207 throw new Error("initializeWasm() must be awaited first!");
9209 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
9210 return nativeResponseValue;
9212 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
9214 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: number): boolean {
9215 if(!isWasmInitialized) {
9216 throw new Error("initializeWasm() must be awaited first!");
9218 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
9219 return nativeResponseValue;
9221 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
9223 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: number): void {
9224 if(!isWasmInitialized) {
9225 throw new Error("initializeWasm() must be awaited first!");
9227 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
9228 // debug statements here
9230 // uintptr_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
9232 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: number): number {
9233 if(!isWasmInitialized) {
9234 throw new Error("initializeWasm() must be awaited first!");
9236 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
9237 return nativeResponseValue;
9239 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
9241 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: number): number {
9242 if(!isWasmInitialized) {
9243 throw new Error("initializeWasm() must be awaited first!");
9245 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
9246 return nativeResponseValue;
9248 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
9250 export function COption_AccessZ_some(o: number): number {
9251 if(!isWasmInitialized) {
9252 throw new Error("initializeWasm() must be awaited first!");
9254 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
9255 return nativeResponseValue;
9257 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
9259 export function COption_AccessZ_none(): number {
9260 if(!isWasmInitialized) {
9261 throw new Error("initializeWasm() must be awaited first!");
9263 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
9264 return nativeResponseValue;
9266 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
9268 export function COption_AccessZ_free(_res: number): void {
9269 if(!isWasmInitialized) {
9270 throw new Error("initializeWasm() must be awaited first!");
9272 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
9273 // debug statements here
9275 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
9277 export function CResult_boolLightningErrorZ_ok(o: boolean): number {
9278 if(!isWasmInitialized) {
9279 throw new Error("initializeWasm() must be awaited first!");
9281 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
9282 return nativeResponseValue;
9284 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
9286 export function CResult_boolLightningErrorZ_err(e: number): number {
9287 if(!isWasmInitialized) {
9288 throw new Error("initializeWasm() must be awaited first!");
9290 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
9291 return nativeResponseValue;
9293 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
9295 export function CResult_boolLightningErrorZ_is_ok(o: number): boolean {
9296 if(!isWasmInitialized) {
9297 throw new Error("initializeWasm() must be awaited first!");
9299 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
9300 return nativeResponseValue;
9302 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
9304 export function CResult_boolLightningErrorZ_free(_res: number): void {
9305 if(!isWasmInitialized) {
9306 throw new Error("initializeWasm() must be awaited first!");
9308 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
9309 // debug statements here
9311 // uintptr_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
9313 export function CResult_boolLightningErrorZ_clone_ptr(arg: number): number {
9314 if(!isWasmInitialized) {
9315 throw new Error("initializeWasm() must be awaited first!");
9317 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
9318 return nativeResponseValue;
9320 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
9322 export function CResult_boolLightningErrorZ_clone(orig: number): number {
9323 if(!isWasmInitialized) {
9324 throw new Error("initializeWasm() must be awaited first!");
9326 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
9327 return nativeResponseValue;
9329 // uintptr_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
9331 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: number): number {
9332 if(!isWasmInitialized) {
9333 throw new Error("initializeWasm() must be awaited first!");
9335 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
9336 return nativeResponseValue;
9338 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
9340 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
9341 if(!isWasmInitialized) {
9342 throw new Error("initializeWasm() must be awaited first!");
9344 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
9345 return nativeResponseValue;
9347 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
9349 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
9350 if(!isWasmInitialized) {
9351 throw new Error("initializeWasm() must be awaited first!");
9353 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
9354 return nativeResponseValue;
9356 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
9358 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
9359 if(!isWasmInitialized) {
9360 throw new Error("initializeWasm() must be awaited first!");
9362 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
9363 // debug statements here
9365 // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
9367 export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number): void {
9368 if(!isWasmInitialized) {
9369 throw new Error("initializeWasm() must be awaited first!");
9371 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
9372 // debug statements here
9374 // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
9376 export function CVec_NodeAnnouncementZ_free(_res: number): void {
9377 if(!isWasmInitialized) {
9378 throw new Error("initializeWasm() must be awaited first!");
9380 const nativeResponseValue = wasm.TS_CVec_NodeAnnouncementZ_free(_res);
9381 // debug statements here
9383 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
9385 export function CResult_NoneLightningErrorZ_ok(): number {
9386 if(!isWasmInitialized) {
9387 throw new Error("initializeWasm() must be awaited first!");
9389 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
9390 return nativeResponseValue;
9392 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
9394 export function CResult_NoneLightningErrorZ_err(e: number): number {
9395 if(!isWasmInitialized) {
9396 throw new Error("initializeWasm() must be awaited first!");
9398 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
9399 return nativeResponseValue;
9401 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
9403 export function CResult_NoneLightningErrorZ_is_ok(o: number): boolean {
9404 if(!isWasmInitialized) {
9405 throw new Error("initializeWasm() must be awaited first!");
9407 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
9408 return nativeResponseValue;
9410 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
9412 export function CResult_NoneLightningErrorZ_free(_res: number): void {
9413 if(!isWasmInitialized) {
9414 throw new Error("initializeWasm() must be awaited first!");
9416 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
9417 // debug statements here
9419 // uintptr_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
9421 export function CResult_NoneLightningErrorZ_clone_ptr(arg: number): number {
9422 if(!isWasmInitialized) {
9423 throw new Error("initializeWasm() must be awaited first!");
9425 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
9426 return nativeResponseValue;
9428 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
9430 export function CResult_NoneLightningErrorZ_clone(orig: number): number {
9431 if(!isWasmInitialized) {
9432 throw new Error("initializeWasm() must be awaited first!");
9434 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
9435 return nativeResponseValue;
9437 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
9439 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: number): number {
9440 if(!isWasmInitialized) {
9441 throw new Error("initializeWasm() must be awaited first!");
9443 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
9444 return nativeResponseValue;
9446 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
9448 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: number): number {
9449 if(!isWasmInitialized) {
9450 throw new Error("initializeWasm() must be awaited first!");
9452 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
9453 return nativeResponseValue;
9455 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
9457 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: number): boolean {
9458 if(!isWasmInitialized) {
9459 throw new Error("initializeWasm() must be awaited first!");
9461 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
9462 return nativeResponseValue;
9464 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
9466 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: number): void {
9467 if(!isWasmInitialized) {
9468 throw new Error("initializeWasm() must be awaited first!");
9470 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
9471 // debug statements here
9473 // uintptr_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
9475 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: number): number {
9476 if(!isWasmInitialized) {
9477 throw new Error("initializeWasm() must be awaited first!");
9479 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
9480 return nativeResponseValue;
9482 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
9484 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: number): number {
9485 if(!isWasmInitialized) {
9486 throw new Error("initializeWasm() must be awaited first!");
9488 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
9489 return nativeResponseValue;
9491 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
9493 export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
9494 if(!isWasmInitialized) {
9495 throw new Error("initializeWasm() must be awaited first!");
9497 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
9498 return nativeResponseValue;
9500 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
9502 export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
9503 if(!isWasmInitialized) {
9504 throw new Error("initializeWasm() must be awaited first!");
9506 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
9507 return nativeResponseValue;
9509 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
9511 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
9512 if(!isWasmInitialized) {
9513 throw new Error("initializeWasm() must be awaited first!");
9515 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
9516 return nativeResponseValue;
9518 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
9520 export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
9521 if(!isWasmInitialized) {
9522 throw new Error("initializeWasm() must be awaited first!");
9524 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
9525 // debug statements here
9527 // uintptr_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
9529 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
9530 if(!isWasmInitialized) {
9531 throw new Error("initializeWasm() must be awaited first!");
9533 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
9534 return nativeResponseValue;
9536 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
9538 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
9539 if(!isWasmInitialized) {
9540 throw new Error("initializeWasm() must be awaited first!");
9542 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
9543 return nativeResponseValue;
9545 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
9547 export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
9548 if(!isWasmInitialized) {
9549 throw new Error("initializeWasm() must be awaited first!");
9551 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
9552 return nativeResponseValue;
9554 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
9556 export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
9557 if(!isWasmInitialized) {
9558 throw new Error("initializeWasm() must be awaited first!");
9560 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
9561 return nativeResponseValue;
9563 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
9565 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: number): boolean {
9566 if(!isWasmInitialized) {
9567 throw new Error("initializeWasm() must be awaited first!");
9569 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
9570 return nativeResponseValue;
9572 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
9574 export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
9575 if(!isWasmInitialized) {
9576 throw new Error("initializeWasm() must be awaited first!");
9578 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
9579 // debug statements here
9581 // uintptr_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
9583 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: number): number {
9584 if(!isWasmInitialized) {
9585 throw new Error("initializeWasm() must be awaited first!");
9587 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
9588 return nativeResponseValue;
9590 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
9592 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
9593 if(!isWasmInitialized) {
9594 throw new Error("initializeWasm() must be awaited first!");
9596 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
9597 return nativeResponseValue;
9599 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
9601 export function CVec_NetAddressZ_free(_res: number): void {
9602 if(!isWasmInitialized) {
9603 throw new Error("initializeWasm() must be awaited first!");
9605 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
9606 // debug statements here
9608 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
9610 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
9611 if(!isWasmInitialized) {
9612 throw new Error("initializeWasm() must be awaited first!");
9614 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
9615 return nativeResponseValue;
9617 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
9619 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
9620 if(!isWasmInitialized) {
9621 throw new Error("initializeWasm() must be awaited first!");
9623 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
9624 return nativeResponseValue;
9626 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
9628 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: number): boolean {
9629 if(!isWasmInitialized) {
9630 throw new Error("initializeWasm() must be awaited first!");
9632 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
9633 return nativeResponseValue;
9635 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
9637 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
9638 if(!isWasmInitialized) {
9639 throw new Error("initializeWasm() must be awaited first!");
9641 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
9642 // debug statements here
9644 // uintptr_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
9646 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: number): number {
9647 if(!isWasmInitialized) {
9648 throw new Error("initializeWasm() must be awaited first!");
9650 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
9651 return nativeResponseValue;
9653 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
9655 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
9656 if(!isWasmInitialized) {
9657 throw new Error("initializeWasm() must be awaited first!");
9659 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
9660 return nativeResponseValue;
9662 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
9664 export function CResult_NodeAliasDecodeErrorZ_ok(o: number): number {
9665 if(!isWasmInitialized) {
9666 throw new Error("initializeWasm() must be awaited first!");
9668 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
9669 return nativeResponseValue;
9671 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
9673 export function CResult_NodeAliasDecodeErrorZ_err(e: number): number {
9674 if(!isWasmInitialized) {
9675 throw new Error("initializeWasm() must be awaited first!");
9677 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
9678 return nativeResponseValue;
9680 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
9682 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: number): boolean {
9683 if(!isWasmInitialized) {
9684 throw new Error("initializeWasm() must be awaited first!");
9686 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
9687 return nativeResponseValue;
9689 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
9691 export function CResult_NodeAliasDecodeErrorZ_free(_res: number): void {
9692 if(!isWasmInitialized) {
9693 throw new Error("initializeWasm() must be awaited first!");
9695 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
9696 // debug statements here
9698 // uintptr_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
9700 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: number): number {
9701 if(!isWasmInitialized) {
9702 throw new Error("initializeWasm() must be awaited first!");
9704 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
9705 return nativeResponseValue;
9707 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
9709 export function CResult_NodeAliasDecodeErrorZ_clone(orig: number): number {
9710 if(!isWasmInitialized) {
9711 throw new Error("initializeWasm() must be awaited first!");
9713 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
9714 return nativeResponseValue;
9716 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
9718 export function CVec_u64Z_free(_res: number): void {
9719 if(!isWasmInitialized) {
9720 throw new Error("initializeWasm() must be awaited first!");
9722 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
9723 // debug statements here
9725 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
9727 export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
9728 if(!isWasmInitialized) {
9729 throw new Error("initializeWasm() must be awaited first!");
9731 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
9732 return nativeResponseValue;
9734 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
9736 export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
9737 if(!isWasmInitialized) {
9738 throw new Error("initializeWasm() must be awaited first!");
9740 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
9741 return nativeResponseValue;
9743 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
9745 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: number): boolean {
9746 if(!isWasmInitialized) {
9747 throw new Error("initializeWasm() must be awaited first!");
9749 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
9750 return nativeResponseValue;
9752 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
9754 export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
9755 if(!isWasmInitialized) {
9756 throw new Error("initializeWasm() must be awaited first!");
9758 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
9759 // debug statements here
9761 // uintptr_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
9763 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: number): number {
9764 if(!isWasmInitialized) {
9765 throw new Error("initializeWasm() must be awaited first!");
9767 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
9768 return nativeResponseValue;
9770 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
9772 export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
9773 if(!isWasmInitialized) {
9774 throw new Error("initializeWasm() must be awaited first!");
9776 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
9777 return nativeResponseValue;
9779 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
9781 export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
9782 if(!isWasmInitialized) {
9783 throw new Error("initializeWasm() must be awaited first!");
9785 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
9786 return nativeResponseValue;
9788 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
9790 export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
9791 if(!isWasmInitialized) {
9792 throw new Error("initializeWasm() must be awaited first!");
9794 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
9795 return nativeResponseValue;
9797 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
9799 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: number): boolean {
9800 if(!isWasmInitialized) {
9801 throw new Error("initializeWasm() must be awaited first!");
9803 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
9804 return nativeResponseValue;
9806 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
9808 export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
9809 if(!isWasmInitialized) {
9810 throw new Error("initializeWasm() must be awaited first!");
9812 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
9813 // debug statements here
9815 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
9817 export function COption_CVec_NetAddressZZ_some(o: number): number {
9818 if(!isWasmInitialized) {
9819 throw new Error("initializeWasm() must be awaited first!");
9821 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
9822 return nativeResponseValue;
9824 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
9826 export function COption_CVec_NetAddressZZ_none(): number {
9827 if(!isWasmInitialized) {
9828 throw new Error("initializeWasm() must be awaited first!");
9830 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
9831 return nativeResponseValue;
9833 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
9835 export function COption_CVec_NetAddressZZ_free(_res: number): void {
9836 if(!isWasmInitialized) {
9837 throw new Error("initializeWasm() must be awaited first!");
9839 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
9840 // debug statements here
9842 // uintptr_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
9844 export function COption_CVec_NetAddressZZ_clone_ptr(arg: number): number {
9845 if(!isWasmInitialized) {
9846 throw new Error("initializeWasm() must be awaited first!");
9848 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
9849 return nativeResponseValue;
9851 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
9853 export function COption_CVec_NetAddressZZ_clone(orig: number): number {
9854 if(!isWasmInitialized) {
9855 throw new Error("initializeWasm() must be awaited first!");
9857 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
9858 return nativeResponseValue;
9860 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
9862 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
9863 if(!isWasmInitialized) {
9864 throw new Error("initializeWasm() must be awaited first!");
9866 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
9867 return nativeResponseValue;
9869 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
9871 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
9872 if(!isWasmInitialized) {
9873 throw new Error("initializeWasm() must be awaited first!");
9875 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
9876 return nativeResponseValue;
9878 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
9880 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
9881 if(!isWasmInitialized) {
9882 throw new Error("initializeWasm() must be awaited first!");
9884 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
9885 return nativeResponseValue;
9887 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
9889 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
9890 if(!isWasmInitialized) {
9891 throw new Error("initializeWasm() must be awaited first!");
9893 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
9894 // debug statements here
9896 // uintptr_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
9898 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
9899 if(!isWasmInitialized) {
9900 throw new Error("initializeWasm() must be awaited first!");
9902 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
9903 return nativeResponseValue;
9905 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
9907 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
9908 if(!isWasmInitialized) {
9909 throw new Error("initializeWasm() must be awaited first!");
9911 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
9912 return nativeResponseValue;
9914 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
9916 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
9917 if(!isWasmInitialized) {
9918 throw new Error("initializeWasm() must be awaited first!");
9920 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
9921 return nativeResponseValue;
9923 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
9925 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
9926 if(!isWasmInitialized) {
9927 throw new Error("initializeWasm() must be awaited first!");
9929 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
9930 return nativeResponseValue;
9932 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
9934 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
9935 if(!isWasmInitialized) {
9936 throw new Error("initializeWasm() must be awaited first!");
9938 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
9939 return nativeResponseValue;
9941 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
9943 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
9944 if(!isWasmInitialized) {
9945 throw new Error("initializeWasm() must be awaited first!");
9947 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
9948 // debug statements here
9950 // uintptr_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
9952 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
9953 if(!isWasmInitialized) {
9954 throw new Error("initializeWasm() must be awaited first!");
9956 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
9957 return nativeResponseValue;
9959 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
9961 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
9962 if(!isWasmInitialized) {
9963 throw new Error("initializeWasm() must be awaited first!");
9965 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
9966 return nativeResponseValue;
9968 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
9970 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
9971 if(!isWasmInitialized) {
9972 throw new Error("initializeWasm() must be awaited first!");
9974 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
9975 return nativeResponseValue;
9977 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
9979 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
9980 if(!isWasmInitialized) {
9981 throw new Error("initializeWasm() must be awaited first!");
9983 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
9984 return nativeResponseValue;
9986 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
9988 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
9989 if(!isWasmInitialized) {
9990 throw new Error("initializeWasm() must be awaited first!");
9992 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
9993 return nativeResponseValue;
9995 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
9997 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
9998 if(!isWasmInitialized) {
9999 throw new Error("initializeWasm() must be awaited first!");
10001 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
10002 // debug statements here
10004 // uintptr_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10006 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10007 if(!isWasmInitialized) {
10008 throw new Error("initializeWasm() must be awaited first!");
10010 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10011 return nativeResponseValue;
10013 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10015 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
10016 if(!isWasmInitialized) {
10017 throw new Error("initializeWasm() must be awaited first!");
10019 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
10020 return nativeResponseValue;
10022 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
10024 export function CVec_PaymentPreimageZ_free(_res: number): void {
10025 if(!isWasmInitialized) {
10026 throw new Error("initializeWasm() must be awaited first!");
10028 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
10029 // debug statements here
10031 // uintptr_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
10033 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: number): number {
10034 if(!isWasmInitialized) {
10035 throw new Error("initializeWasm() must be awaited first!");
10037 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
10038 return nativeResponseValue;
10040 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
10042 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
10043 if(!isWasmInitialized) {
10044 throw new Error("initializeWasm() must be awaited first!");
10046 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
10047 return nativeResponseValue;
10049 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
10051 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): number {
10052 if(!isWasmInitialized) {
10053 throw new Error("initializeWasm() must be awaited first!");
10055 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
10056 return nativeResponseValue;
10058 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
10060 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
10061 if(!isWasmInitialized) {
10062 throw new Error("initializeWasm() must be awaited first!");
10064 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
10065 // debug statements here
10067 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
10069 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
10070 if(!isWasmInitialized) {
10071 throw new Error("initializeWasm() must be awaited first!");
10073 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
10074 return nativeResponseValue;
10076 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
10078 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
10079 if(!isWasmInitialized) {
10080 throw new Error("initializeWasm() must be awaited first!");
10082 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
10083 return nativeResponseValue;
10085 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
10087 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: number): boolean {
10088 if(!isWasmInitialized) {
10089 throw new Error("initializeWasm() must be awaited first!");
10091 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
10092 return nativeResponseValue;
10094 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
10096 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
10097 if(!isWasmInitialized) {
10098 throw new Error("initializeWasm() must be awaited first!");
10100 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
10101 // debug statements here
10103 // uintptr_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
10105 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: number): number {
10106 if(!isWasmInitialized) {
10107 throw new Error("initializeWasm() must be awaited first!");
10109 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
10110 return nativeResponseValue;
10112 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
10114 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
10115 if(!isWasmInitialized) {
10116 throw new Error("initializeWasm() must be awaited first!");
10118 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
10119 return nativeResponseValue;
10121 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
10123 export function CResult_SignatureNoneZ_ok(o: number): number {
10124 if(!isWasmInitialized) {
10125 throw new Error("initializeWasm() must be awaited first!");
10127 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
10128 return nativeResponseValue;
10130 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
10132 export function CResult_SignatureNoneZ_err(): number {
10133 if(!isWasmInitialized) {
10134 throw new Error("initializeWasm() must be awaited first!");
10136 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
10137 return nativeResponseValue;
10139 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
10141 export function CResult_SignatureNoneZ_is_ok(o: number): boolean {
10142 if(!isWasmInitialized) {
10143 throw new Error("initializeWasm() must be awaited first!");
10145 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
10146 return nativeResponseValue;
10148 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
10150 export function CResult_SignatureNoneZ_free(_res: number): void {
10151 if(!isWasmInitialized) {
10152 throw new Error("initializeWasm() must be awaited first!");
10154 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
10155 // debug statements here
10157 // uintptr_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
10159 export function CResult_SignatureNoneZ_clone_ptr(arg: number): number {
10160 if(!isWasmInitialized) {
10161 throw new Error("initializeWasm() must be awaited first!");
10163 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
10164 return nativeResponseValue;
10166 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
10168 export function CResult_SignatureNoneZ_clone(orig: number): number {
10169 if(!isWasmInitialized) {
10170 throw new Error("initializeWasm() must be awaited first!");
10172 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
10173 return nativeResponseValue;
10175 // uintptr_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
10177 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: number): number {
10178 if(!isWasmInitialized) {
10179 throw new Error("initializeWasm() must be awaited first!");
10181 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
10182 return nativeResponseValue;
10184 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
10186 export function C2Tuple_SignatureSignatureZ_clone(orig: number): number {
10187 if(!isWasmInitialized) {
10188 throw new Error("initializeWasm() must be awaited first!");
10190 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
10191 return nativeResponseValue;
10193 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
10195 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): number {
10196 if(!isWasmInitialized) {
10197 throw new Error("initializeWasm() must be awaited first!");
10199 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
10200 return nativeResponseValue;
10202 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
10204 export function C2Tuple_SignatureSignatureZ_free(_res: number): void {
10205 if(!isWasmInitialized) {
10206 throw new Error("initializeWasm() must be awaited first!");
10208 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
10209 // debug statements here
10211 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
10213 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: number): number {
10214 if(!isWasmInitialized) {
10215 throw new Error("initializeWasm() must be awaited first!");
10217 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
10218 return nativeResponseValue;
10220 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
10222 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): number {
10223 if(!isWasmInitialized) {
10224 throw new Error("initializeWasm() must be awaited first!");
10226 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
10227 return nativeResponseValue;
10229 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
10231 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: number): boolean {
10232 if(!isWasmInitialized) {
10233 throw new Error("initializeWasm() must be awaited first!");
10235 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
10236 return nativeResponseValue;
10238 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
10240 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: number): void {
10241 if(!isWasmInitialized) {
10242 throw new Error("initializeWasm() must be awaited first!");
10244 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
10245 // debug statements here
10247 // uintptr_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
10249 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: number): number {
10250 if(!isWasmInitialized) {
10251 throw new Error("initializeWasm() must be awaited first!");
10253 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
10254 return nativeResponseValue;
10256 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
10258 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: number): number {
10259 if(!isWasmInitialized) {
10260 throw new Error("initializeWasm() must be awaited first!");
10262 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
10263 return nativeResponseValue;
10265 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
10267 export function CResult_SecretKeyNoneZ_ok(o: number): number {
10268 if(!isWasmInitialized) {
10269 throw new Error("initializeWasm() must be awaited first!");
10271 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
10272 return nativeResponseValue;
10274 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
10276 export function CResult_SecretKeyNoneZ_err(): number {
10277 if(!isWasmInitialized) {
10278 throw new Error("initializeWasm() must be awaited first!");
10280 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
10281 return nativeResponseValue;
10283 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
10285 export function CResult_SecretKeyNoneZ_is_ok(o: number): boolean {
10286 if(!isWasmInitialized) {
10287 throw new Error("initializeWasm() must be awaited first!");
10289 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
10290 return nativeResponseValue;
10292 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
10294 export function CResult_SecretKeyNoneZ_free(_res: number): void {
10295 if(!isWasmInitialized) {
10296 throw new Error("initializeWasm() must be awaited first!");
10298 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
10299 // debug statements here
10301 // uintptr_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
10303 export function CResult_SecretKeyNoneZ_clone_ptr(arg: number): number {
10304 if(!isWasmInitialized) {
10305 throw new Error("initializeWasm() must be awaited first!");
10307 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
10308 return nativeResponseValue;
10310 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
10312 export function CResult_SecretKeyNoneZ_clone(orig: number): number {
10313 if(!isWasmInitialized) {
10314 throw new Error("initializeWasm() must be awaited first!");
10316 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
10317 return nativeResponseValue;
10319 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
10321 export function CResult_SignDecodeErrorZ_ok(o: number): number {
10322 if(!isWasmInitialized) {
10323 throw new Error("initializeWasm() must be awaited first!");
10325 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
10326 return nativeResponseValue;
10328 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
10330 export function CResult_SignDecodeErrorZ_err(e: number): number {
10331 if(!isWasmInitialized) {
10332 throw new Error("initializeWasm() must be awaited first!");
10334 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
10335 return nativeResponseValue;
10337 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
10339 export function CResult_SignDecodeErrorZ_is_ok(o: number): boolean {
10340 if(!isWasmInitialized) {
10341 throw new Error("initializeWasm() must be awaited first!");
10343 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
10344 return nativeResponseValue;
10346 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
10348 export function CResult_SignDecodeErrorZ_free(_res: number): void {
10349 if(!isWasmInitialized) {
10350 throw new Error("initializeWasm() must be awaited first!");
10352 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
10353 // debug statements here
10355 // uintptr_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
10357 export function CResult_SignDecodeErrorZ_clone_ptr(arg: number): number {
10358 if(!isWasmInitialized) {
10359 throw new Error("initializeWasm() must be awaited first!");
10361 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
10362 return nativeResponseValue;
10364 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
10366 export function CResult_SignDecodeErrorZ_clone(orig: number): number {
10367 if(!isWasmInitialized) {
10368 throw new Error("initializeWasm() must be awaited first!");
10370 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
10371 return nativeResponseValue;
10373 // void CVec_u5Z_free(struct LDKCVec_u5Z _res);
10375 export function CVec_u5Z_free(_res: number): void {
10376 if(!isWasmInitialized) {
10377 throw new Error("initializeWasm() must be awaited first!");
10379 const nativeResponseValue = wasm.TS_CVec_u5Z_free(_res);
10380 // debug statements here
10382 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
10384 export function CResult_RecoverableSignatureNoneZ_ok(o: number): number {
10385 if(!isWasmInitialized) {
10386 throw new Error("initializeWasm() must be awaited first!");
10388 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
10389 return nativeResponseValue;
10391 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
10393 export function CResult_RecoverableSignatureNoneZ_err(): number {
10394 if(!isWasmInitialized) {
10395 throw new Error("initializeWasm() must be awaited first!");
10397 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
10398 return nativeResponseValue;
10400 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
10402 export function CResult_RecoverableSignatureNoneZ_is_ok(o: number): boolean {
10403 if(!isWasmInitialized) {
10404 throw new Error("initializeWasm() must be awaited first!");
10406 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
10407 return nativeResponseValue;
10409 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
10411 export function CResult_RecoverableSignatureNoneZ_free(_res: number): void {
10412 if(!isWasmInitialized) {
10413 throw new Error("initializeWasm() must be awaited first!");
10415 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
10416 // debug statements here
10418 // uintptr_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
10420 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: number): number {
10421 if(!isWasmInitialized) {
10422 throw new Error("initializeWasm() must be awaited first!");
10424 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
10425 return nativeResponseValue;
10427 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
10429 export function CResult_RecoverableSignatureNoneZ_clone(orig: number): number {
10430 if(!isWasmInitialized) {
10431 throw new Error("initializeWasm() must be awaited first!");
10433 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
10434 return nativeResponseValue;
10436 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
10438 export function CVec_u8Z_free(_res: number): void {
10439 if(!isWasmInitialized) {
10440 throw new Error("initializeWasm() must be awaited first!");
10442 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
10443 // debug statements here
10445 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
10447 export function CVec_CVec_u8ZZ_free(_res: number): void {
10448 if(!isWasmInitialized) {
10449 throw new Error("initializeWasm() must be awaited first!");
10451 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
10452 // debug statements here
10454 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
10456 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): number {
10457 if(!isWasmInitialized) {
10458 throw new Error("initializeWasm() must be awaited first!");
10460 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
10461 return nativeResponseValue;
10463 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
10465 export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
10466 if(!isWasmInitialized) {
10467 throw new Error("initializeWasm() must be awaited first!");
10469 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
10470 return nativeResponseValue;
10472 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
10474 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: number): boolean {
10475 if(!isWasmInitialized) {
10476 throw new Error("initializeWasm() must be awaited first!");
10478 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
10479 return nativeResponseValue;
10481 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
10483 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
10484 if(!isWasmInitialized) {
10485 throw new Error("initializeWasm() must be awaited first!");
10487 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
10488 // debug statements here
10490 // uintptr_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
10492 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: number): number {
10493 if(!isWasmInitialized) {
10494 throw new Error("initializeWasm() must be awaited first!");
10496 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
10497 return nativeResponseValue;
10499 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
10501 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
10502 if(!isWasmInitialized) {
10503 throw new Error("initializeWasm() must be awaited first!");
10505 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
10506 return nativeResponseValue;
10508 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
10510 export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
10511 if(!isWasmInitialized) {
10512 throw new Error("initializeWasm() must be awaited first!");
10514 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
10515 return nativeResponseValue;
10517 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
10519 export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
10520 if(!isWasmInitialized) {
10521 throw new Error("initializeWasm() must be awaited first!");
10523 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
10524 return nativeResponseValue;
10526 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
10528 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: number): boolean {
10529 if(!isWasmInitialized) {
10530 throw new Error("initializeWasm() must be awaited first!");
10532 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
10533 return nativeResponseValue;
10535 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
10537 export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
10538 if(!isWasmInitialized) {
10539 throw new Error("initializeWasm() must be awaited first!");
10541 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
10542 // debug statements here
10544 // uintptr_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
10546 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: number): number {
10547 if(!isWasmInitialized) {
10548 throw new Error("initializeWasm() must be awaited first!");
10550 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
10551 return nativeResponseValue;
10553 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
10555 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
10556 if(!isWasmInitialized) {
10557 throw new Error("initializeWasm() must be awaited first!");
10559 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
10560 return nativeResponseValue;
10562 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
10564 export function CVec_TxOutZ_free(_res: number): void {
10565 if(!isWasmInitialized) {
10566 throw new Error("initializeWasm() must be awaited first!");
10568 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
10569 // debug statements here
10571 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
10573 export function CResult_TransactionNoneZ_ok(o: number): number {
10574 if(!isWasmInitialized) {
10575 throw new Error("initializeWasm() must be awaited first!");
10577 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
10578 return nativeResponseValue;
10580 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
10582 export function CResult_TransactionNoneZ_err(): number {
10583 if(!isWasmInitialized) {
10584 throw new Error("initializeWasm() must be awaited first!");
10586 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
10587 return nativeResponseValue;
10589 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
10591 export function CResult_TransactionNoneZ_is_ok(o: number): boolean {
10592 if(!isWasmInitialized) {
10593 throw new Error("initializeWasm() must be awaited first!");
10595 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
10596 return nativeResponseValue;
10598 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
10600 export function CResult_TransactionNoneZ_free(_res: number): void {
10601 if(!isWasmInitialized) {
10602 throw new Error("initializeWasm() must be awaited first!");
10604 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
10605 // debug statements here
10607 // uintptr_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
10609 export function CResult_TransactionNoneZ_clone_ptr(arg: number): number {
10610 if(!isWasmInitialized) {
10611 throw new Error("initializeWasm() must be awaited first!");
10613 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
10614 return nativeResponseValue;
10616 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
10618 export function CResult_TransactionNoneZ_clone(orig: number): number {
10619 if(!isWasmInitialized) {
10620 throw new Error("initializeWasm() must be awaited first!");
10622 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
10623 return nativeResponseValue;
10625 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
10627 export function COption_u16Z_some(o: number): number {
10628 if(!isWasmInitialized) {
10629 throw new Error("initializeWasm() must be awaited first!");
10631 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
10632 return nativeResponseValue;
10634 // struct LDKCOption_u16Z COption_u16Z_none(void);
10636 export function COption_u16Z_none(): number {
10637 if(!isWasmInitialized) {
10638 throw new Error("initializeWasm() must be awaited first!");
10640 const nativeResponseValue = wasm.TS_COption_u16Z_none();
10641 return nativeResponseValue;
10643 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
10645 export function COption_u16Z_free(_res: number): void {
10646 if(!isWasmInitialized) {
10647 throw new Error("initializeWasm() must be awaited first!");
10649 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
10650 // debug statements here
10652 // uintptr_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
10654 export function COption_u16Z_clone_ptr(arg: number): number {
10655 if(!isWasmInitialized) {
10656 throw new Error("initializeWasm() must be awaited first!");
10658 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
10659 return nativeResponseValue;
10661 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
10663 export function COption_u16Z_clone(orig: number): number {
10664 if(!isWasmInitialized) {
10665 throw new Error("initializeWasm() must be awaited first!");
10667 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
10668 return nativeResponseValue;
10670 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
10672 export function CResult_NoneAPIErrorZ_ok(): number {
10673 if(!isWasmInitialized) {
10674 throw new Error("initializeWasm() must be awaited first!");
10676 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
10677 return nativeResponseValue;
10679 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
10681 export function CResult_NoneAPIErrorZ_err(e: number): number {
10682 if(!isWasmInitialized) {
10683 throw new Error("initializeWasm() must be awaited first!");
10685 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
10686 return nativeResponseValue;
10688 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
10690 export function CResult_NoneAPIErrorZ_is_ok(o: number): boolean {
10691 if(!isWasmInitialized) {
10692 throw new Error("initializeWasm() must be awaited first!");
10694 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
10695 return nativeResponseValue;
10697 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
10699 export function CResult_NoneAPIErrorZ_free(_res: number): void {
10700 if(!isWasmInitialized) {
10701 throw new Error("initializeWasm() must be awaited first!");
10703 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
10704 // debug statements here
10706 // uintptr_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
10708 export function CResult_NoneAPIErrorZ_clone_ptr(arg: number): number {
10709 if(!isWasmInitialized) {
10710 throw new Error("initializeWasm() must be awaited first!");
10712 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
10713 return nativeResponseValue;
10715 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
10717 export function CResult_NoneAPIErrorZ_clone(orig: number): number {
10718 if(!isWasmInitialized) {
10719 throw new Error("initializeWasm() must be awaited first!");
10721 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
10722 return nativeResponseValue;
10724 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
10726 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
10727 if(!isWasmInitialized) {
10728 throw new Error("initializeWasm() must be awaited first!");
10730 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
10731 // debug statements here
10733 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
10735 export function CVec_APIErrorZ_free(_res: number): void {
10736 if(!isWasmInitialized) {
10737 throw new Error("initializeWasm() must be awaited first!");
10739 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
10740 // debug statements here
10742 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
10744 export function CResult__u832APIErrorZ_ok(o: number): number {
10745 if(!isWasmInitialized) {
10746 throw new Error("initializeWasm() must be awaited first!");
10748 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
10749 return nativeResponseValue;
10751 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
10753 export function CResult__u832APIErrorZ_err(e: number): number {
10754 if(!isWasmInitialized) {
10755 throw new Error("initializeWasm() must be awaited first!");
10757 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
10758 return nativeResponseValue;
10760 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
10762 export function CResult__u832APIErrorZ_is_ok(o: number): boolean {
10763 if(!isWasmInitialized) {
10764 throw new Error("initializeWasm() must be awaited first!");
10766 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
10767 return nativeResponseValue;
10769 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
10771 export function CResult__u832APIErrorZ_free(_res: number): void {
10772 if(!isWasmInitialized) {
10773 throw new Error("initializeWasm() must be awaited first!");
10775 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
10776 // debug statements here
10778 // uintptr_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
10780 export function CResult__u832APIErrorZ_clone_ptr(arg: number): number {
10781 if(!isWasmInitialized) {
10782 throw new Error("initializeWasm() must be awaited first!");
10784 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
10785 return nativeResponseValue;
10787 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
10789 export function CResult__u832APIErrorZ_clone(orig: number): number {
10790 if(!isWasmInitialized) {
10791 throw new Error("initializeWasm() must be awaited first!");
10793 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
10794 return nativeResponseValue;
10796 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
10798 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): number {
10799 if(!isWasmInitialized) {
10800 throw new Error("initializeWasm() must be awaited first!");
10802 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
10803 return nativeResponseValue;
10805 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
10807 export function CResult_PaymentIdPaymentSendFailureZ_err(e: number): number {
10808 if(!isWasmInitialized) {
10809 throw new Error("initializeWasm() must be awaited first!");
10811 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
10812 return nativeResponseValue;
10814 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
10816 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: number): boolean {
10817 if(!isWasmInitialized) {
10818 throw new Error("initializeWasm() must be awaited first!");
10820 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
10821 return nativeResponseValue;
10823 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
10825 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: number): void {
10826 if(!isWasmInitialized) {
10827 throw new Error("initializeWasm() must be awaited first!");
10829 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
10830 // debug statements here
10832 // uintptr_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
10834 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: number): number {
10835 if(!isWasmInitialized) {
10836 throw new Error("initializeWasm() must be awaited first!");
10838 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
10839 return nativeResponseValue;
10841 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
10843 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: number): number {
10844 if(!isWasmInitialized) {
10845 throw new Error("initializeWasm() must be awaited first!");
10847 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
10848 return nativeResponseValue;
10850 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
10852 export function CResult_NonePaymentSendFailureZ_ok(): number {
10853 if(!isWasmInitialized) {
10854 throw new Error("initializeWasm() must be awaited first!");
10856 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
10857 return nativeResponseValue;
10859 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
10861 export function CResult_NonePaymentSendFailureZ_err(e: number): number {
10862 if(!isWasmInitialized) {
10863 throw new Error("initializeWasm() must be awaited first!");
10865 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
10866 return nativeResponseValue;
10868 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
10870 export function CResult_NonePaymentSendFailureZ_is_ok(o: number): boolean {
10871 if(!isWasmInitialized) {
10872 throw new Error("initializeWasm() must be awaited first!");
10874 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
10875 return nativeResponseValue;
10877 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
10879 export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
10880 if(!isWasmInitialized) {
10881 throw new Error("initializeWasm() must be awaited first!");
10883 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
10884 // debug statements here
10886 // uintptr_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
10888 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: number): number {
10889 if(!isWasmInitialized) {
10890 throw new Error("initializeWasm() must be awaited first!");
10892 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
10893 return nativeResponseValue;
10895 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
10897 export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
10898 if(!isWasmInitialized) {
10899 throw new Error("initializeWasm() must be awaited first!");
10901 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
10902 return nativeResponseValue;
10904 // uintptr_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
10906 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: number): number {
10907 if(!isWasmInitialized) {
10908 throw new Error("initializeWasm() must be awaited first!");
10910 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
10911 return nativeResponseValue;
10913 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
10915 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: number): number {
10916 if(!isWasmInitialized) {
10917 throw new Error("initializeWasm() must be awaited first!");
10919 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
10920 return nativeResponseValue;
10922 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
10924 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): number {
10925 if(!isWasmInitialized) {
10926 throw new Error("initializeWasm() must be awaited first!");
10928 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
10929 return nativeResponseValue;
10931 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
10933 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: number): void {
10934 if(!isWasmInitialized) {
10935 throw new Error("initializeWasm() must be awaited first!");
10937 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
10938 // debug statements here
10940 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
10942 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: number): number {
10943 if(!isWasmInitialized) {
10944 throw new Error("initializeWasm() must be awaited first!");
10946 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
10947 return nativeResponseValue;
10949 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
10951 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: number): number {
10952 if(!isWasmInitialized) {
10953 throw new Error("initializeWasm() must be awaited first!");
10955 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
10956 return nativeResponseValue;
10958 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
10960 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: number): boolean {
10961 if(!isWasmInitialized) {
10962 throw new Error("initializeWasm() must be awaited first!");
10964 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
10965 return nativeResponseValue;
10967 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
10969 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: number): void {
10970 if(!isWasmInitialized) {
10971 throw new Error("initializeWasm() must be awaited first!");
10973 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
10974 // debug statements here
10976 // uintptr_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
10978 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: number): number {
10979 if(!isWasmInitialized) {
10980 throw new Error("initializeWasm() must be awaited first!");
10982 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
10983 return nativeResponseValue;
10985 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
10987 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: number): number {
10988 if(!isWasmInitialized) {
10989 throw new Error("initializeWasm() must be awaited first!");
10991 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
10992 return nativeResponseValue;
10994 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
10996 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
10997 if(!isWasmInitialized) {
10998 throw new Error("initializeWasm() must be awaited first!");
11000 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
11001 // debug statements here
11003 // uintptr_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
11005 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: number): number {
11006 if(!isWasmInitialized) {
11007 throw new Error("initializeWasm() must be awaited first!");
11009 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
11010 return nativeResponseValue;
11012 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
11014 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: number): number {
11015 if(!isWasmInitialized) {
11016 throw new Error("initializeWasm() must be awaited first!");
11018 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
11019 return nativeResponseValue;
11021 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
11023 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): number {
11024 if(!isWasmInitialized) {
11025 throw new Error("initializeWasm() must be awaited first!");
11027 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
11028 return nativeResponseValue;
11030 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
11032 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: number): void {
11033 if(!isWasmInitialized) {
11034 throw new Error("initializeWasm() must be awaited first!");
11036 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
11037 // debug statements here
11039 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11041 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: number): number {
11042 if(!isWasmInitialized) {
11043 throw new Error("initializeWasm() must be awaited first!");
11045 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
11046 return nativeResponseValue;
11048 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
11050 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): number {
11051 if(!isWasmInitialized) {
11052 throw new Error("initializeWasm() must be awaited first!");
11054 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
11055 return nativeResponseValue;
11057 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
11059 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: number): boolean {
11060 if(!isWasmInitialized) {
11061 throw new Error("initializeWasm() must be awaited first!");
11063 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
11064 return nativeResponseValue;
11066 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
11068 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: number): void {
11069 if(!isWasmInitialized) {
11070 throw new Error("initializeWasm() must be awaited first!");
11072 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
11073 // debug statements here
11075 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
11077 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: number): number {
11078 if(!isWasmInitialized) {
11079 throw new Error("initializeWasm() must be awaited first!");
11081 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
11082 return nativeResponseValue;
11084 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
11086 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: number): number {
11087 if(!isWasmInitialized) {
11088 throw new Error("initializeWasm() must be awaited first!");
11090 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
11091 return nativeResponseValue;
11093 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11095 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: number): number {
11096 if(!isWasmInitialized) {
11097 throw new Error("initializeWasm() must be awaited first!");
11099 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
11100 return nativeResponseValue;
11102 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
11104 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: number): number {
11105 if(!isWasmInitialized) {
11106 throw new Error("initializeWasm() must be awaited first!");
11108 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
11109 return nativeResponseValue;
11111 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
11113 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: number): boolean {
11114 if(!isWasmInitialized) {
11115 throw new Error("initializeWasm() must be awaited first!");
11117 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
11118 return nativeResponseValue;
11120 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
11122 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: number): void {
11123 if(!isWasmInitialized) {
11124 throw new Error("initializeWasm() must be awaited first!");
11126 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
11127 // debug statements here
11129 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
11131 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: number): number {
11132 if(!isWasmInitialized) {
11133 throw new Error("initializeWasm() must be awaited first!");
11135 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
11136 return nativeResponseValue;
11138 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
11140 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: number): number {
11141 if(!isWasmInitialized) {
11142 throw new Error("initializeWasm() must be awaited first!");
11144 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
11145 return nativeResponseValue;
11147 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
11149 export function CResult_PaymentSecretNoneZ_ok(o: number): number {
11150 if(!isWasmInitialized) {
11151 throw new Error("initializeWasm() must be awaited first!");
11153 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
11154 return nativeResponseValue;
11156 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
11158 export function CResult_PaymentSecretNoneZ_err(): number {
11159 if(!isWasmInitialized) {
11160 throw new Error("initializeWasm() must be awaited first!");
11162 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
11163 return nativeResponseValue;
11165 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
11167 export function CResult_PaymentSecretNoneZ_is_ok(o: number): boolean {
11168 if(!isWasmInitialized) {
11169 throw new Error("initializeWasm() must be awaited first!");
11171 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
11172 return nativeResponseValue;
11174 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
11176 export function CResult_PaymentSecretNoneZ_free(_res: number): void {
11177 if(!isWasmInitialized) {
11178 throw new Error("initializeWasm() must be awaited first!");
11180 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
11181 // debug statements here
11183 // uintptr_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
11185 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: number): number {
11186 if(!isWasmInitialized) {
11187 throw new Error("initializeWasm() must be awaited first!");
11189 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
11190 return nativeResponseValue;
11192 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
11194 export function CResult_PaymentSecretNoneZ_clone(orig: number): number {
11195 if(!isWasmInitialized) {
11196 throw new Error("initializeWasm() must be awaited first!");
11198 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
11199 return nativeResponseValue;
11201 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
11203 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): number {
11204 if(!isWasmInitialized) {
11205 throw new Error("initializeWasm() must be awaited first!");
11207 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
11208 return nativeResponseValue;
11210 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
11212 export function CResult_PaymentSecretAPIErrorZ_err(e: number): number {
11213 if(!isWasmInitialized) {
11214 throw new Error("initializeWasm() must be awaited first!");
11216 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
11217 return nativeResponseValue;
11219 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
11221 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: number): boolean {
11222 if(!isWasmInitialized) {
11223 throw new Error("initializeWasm() must be awaited first!");
11225 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
11226 return nativeResponseValue;
11228 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
11230 export function CResult_PaymentSecretAPIErrorZ_free(_res: number): void {
11231 if(!isWasmInitialized) {
11232 throw new Error("initializeWasm() must be awaited first!");
11234 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
11235 // debug statements here
11237 // uintptr_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
11239 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: number): number {
11240 if(!isWasmInitialized) {
11241 throw new Error("initializeWasm() must be awaited first!");
11243 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
11244 return nativeResponseValue;
11246 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
11248 export function CResult_PaymentSecretAPIErrorZ_clone(orig: number): number {
11249 if(!isWasmInitialized) {
11250 throw new Error("initializeWasm() must be awaited first!");
11252 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
11253 return nativeResponseValue;
11255 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
11257 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): number {
11258 if(!isWasmInitialized) {
11259 throw new Error("initializeWasm() must be awaited first!");
11261 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
11262 return nativeResponseValue;
11264 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
11266 export function CResult_PaymentPreimageAPIErrorZ_err(e: number): number {
11267 if(!isWasmInitialized) {
11268 throw new Error("initializeWasm() must be awaited first!");
11270 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
11271 return nativeResponseValue;
11273 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
11275 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: number): boolean {
11276 if(!isWasmInitialized) {
11277 throw new Error("initializeWasm() must be awaited first!");
11279 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
11280 return nativeResponseValue;
11282 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
11284 export function CResult_PaymentPreimageAPIErrorZ_free(_res: number): void {
11285 if(!isWasmInitialized) {
11286 throw new Error("initializeWasm() must be awaited first!");
11288 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
11289 // debug statements here
11291 // uintptr_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
11293 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: number): number {
11294 if(!isWasmInitialized) {
11295 throw new Error("initializeWasm() must be awaited first!");
11297 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
11298 return nativeResponseValue;
11300 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
11302 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: number): number {
11303 if(!isWasmInitialized) {
11304 throw new Error("initializeWasm() must be awaited first!");
11306 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
11307 return nativeResponseValue;
11309 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
11311 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: number): number {
11312 if(!isWasmInitialized) {
11313 throw new Error("initializeWasm() must be awaited first!");
11315 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
11316 return nativeResponseValue;
11318 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
11320 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: number): number {
11321 if(!isWasmInitialized) {
11322 throw new Error("initializeWasm() must be awaited first!");
11324 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
11325 return nativeResponseValue;
11327 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
11329 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: number): boolean {
11330 if(!isWasmInitialized) {
11331 throw new Error("initializeWasm() must be awaited first!");
11333 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
11334 return nativeResponseValue;
11336 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
11338 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: number): void {
11339 if(!isWasmInitialized) {
11340 throw new Error("initializeWasm() must be awaited first!");
11342 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
11343 // debug statements here
11345 // uintptr_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
11347 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: number): number {
11348 if(!isWasmInitialized) {
11349 throw new Error("initializeWasm() must be awaited first!");
11351 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
11352 return nativeResponseValue;
11354 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
11356 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: number): number {
11357 if(!isWasmInitialized) {
11358 throw new Error("initializeWasm() must be awaited first!");
11360 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
11361 return nativeResponseValue;
11363 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
11365 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: number): number {
11366 if(!isWasmInitialized) {
11367 throw new Error("initializeWasm() must be awaited first!");
11369 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
11370 return nativeResponseValue;
11372 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
11374 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: number): number {
11375 if(!isWasmInitialized) {
11376 throw new Error("initializeWasm() must be awaited first!");
11378 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
11379 return nativeResponseValue;
11381 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
11383 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: number): boolean {
11384 if(!isWasmInitialized) {
11385 throw new Error("initializeWasm() must be awaited first!");
11387 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
11388 return nativeResponseValue;
11390 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
11392 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: number): void {
11393 if(!isWasmInitialized) {
11394 throw new Error("initializeWasm() must be awaited first!");
11396 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
11397 // debug statements here
11399 // uintptr_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
11401 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: number): number {
11402 if(!isWasmInitialized) {
11403 throw new Error("initializeWasm() must be awaited first!");
11405 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
11406 return nativeResponseValue;
11408 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
11410 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: number): number {
11411 if(!isWasmInitialized) {
11412 throw new Error("initializeWasm() must be awaited first!");
11414 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
11415 return nativeResponseValue;
11417 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
11419 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: number): number {
11420 if(!isWasmInitialized) {
11421 throw new Error("initializeWasm() must be awaited first!");
11423 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
11424 return nativeResponseValue;
11426 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
11428 export function CResult_ChannelDetailsDecodeErrorZ_err(e: number): number {
11429 if(!isWasmInitialized) {
11430 throw new Error("initializeWasm() must be awaited first!");
11432 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
11433 return nativeResponseValue;
11435 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
11437 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: number): boolean {
11438 if(!isWasmInitialized) {
11439 throw new Error("initializeWasm() must be awaited first!");
11441 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
11442 return nativeResponseValue;
11444 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
11446 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: number): void {
11447 if(!isWasmInitialized) {
11448 throw new Error("initializeWasm() must be awaited first!");
11450 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
11451 // debug statements here
11453 // uintptr_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
11455 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: number): number {
11456 if(!isWasmInitialized) {
11457 throw new Error("initializeWasm() must be awaited first!");
11459 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
11460 return nativeResponseValue;
11462 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
11464 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: number): number {
11465 if(!isWasmInitialized) {
11466 throw new Error("initializeWasm() must be awaited first!");
11468 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
11469 return nativeResponseValue;
11471 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
11473 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: number): number {
11474 if(!isWasmInitialized) {
11475 throw new Error("initializeWasm() must be awaited first!");
11477 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
11478 return nativeResponseValue;
11480 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
11482 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: number): number {
11483 if(!isWasmInitialized) {
11484 throw new Error("initializeWasm() must be awaited first!");
11486 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
11487 return nativeResponseValue;
11489 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
11491 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: number): boolean {
11492 if(!isWasmInitialized) {
11493 throw new Error("initializeWasm() must be awaited first!");
11495 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
11496 return nativeResponseValue;
11498 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
11500 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: number): void {
11501 if(!isWasmInitialized) {
11502 throw new Error("initializeWasm() must be awaited first!");
11504 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
11505 // debug statements here
11507 // uintptr_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
11509 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: number): number {
11510 if(!isWasmInitialized) {
11511 throw new Error("initializeWasm() must be awaited first!");
11513 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
11514 return nativeResponseValue;
11516 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
11518 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: number): number {
11519 if(!isWasmInitialized) {
11520 throw new Error("initializeWasm() must be awaited first!");
11522 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
11523 return nativeResponseValue;
11525 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
11527 export function CVec_ChannelMonitorZ_free(_res: number): void {
11528 if(!isWasmInitialized) {
11529 throw new Error("initializeWasm() must be awaited first!");
11531 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
11532 // debug statements here
11534 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
11536 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: number): number {
11537 if(!isWasmInitialized) {
11538 throw new Error("initializeWasm() must be awaited first!");
11540 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
11541 return nativeResponseValue;
11543 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
11545 export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
11546 if(!isWasmInitialized) {
11547 throw new Error("initializeWasm() must be awaited first!");
11549 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
11550 // debug statements here
11552 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
11554 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
11555 if(!isWasmInitialized) {
11556 throw new Error("initializeWasm() must be awaited first!");
11558 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
11559 return nativeResponseValue;
11561 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
11563 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
11564 if(!isWasmInitialized) {
11565 throw new Error("initializeWasm() must be awaited first!");
11567 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
11568 return nativeResponseValue;
11570 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
11572 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: number): boolean {
11573 if(!isWasmInitialized) {
11574 throw new Error("initializeWasm() must be awaited first!");
11576 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
11577 return nativeResponseValue;
11579 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
11581 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
11582 if(!isWasmInitialized) {
11583 throw new Error("initializeWasm() must be awaited first!");
11585 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
11586 // debug statements here
11588 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
11590 export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
11591 if(!isWasmInitialized) {
11592 throw new Error("initializeWasm() must be awaited first!");
11594 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
11595 return nativeResponseValue;
11597 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
11599 export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
11600 if(!isWasmInitialized) {
11601 throw new Error("initializeWasm() must be awaited first!");
11603 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
11604 return nativeResponseValue;
11606 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
11608 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: number): boolean {
11609 if(!isWasmInitialized) {
11610 throw new Error("initializeWasm() must be awaited first!");
11612 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
11613 return nativeResponseValue;
11615 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
11617 export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
11618 if(!isWasmInitialized) {
11619 throw new Error("initializeWasm() must be awaited first!");
11621 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
11622 // debug statements here
11624 // uintptr_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
11626 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: number): number {
11627 if(!isWasmInitialized) {
11628 throw new Error("initializeWasm() must be awaited first!");
11630 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
11631 return nativeResponseValue;
11633 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
11635 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
11636 if(!isWasmInitialized) {
11637 throw new Error("initializeWasm() must be awaited first!");
11639 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
11640 return nativeResponseValue;
11642 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
11644 export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
11645 if(!isWasmInitialized) {
11646 throw new Error("initializeWasm() must be awaited first!");
11648 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
11649 return nativeResponseValue;
11651 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
11653 export function CResult_OutPointDecodeErrorZ_err(e: number): number {
11654 if(!isWasmInitialized) {
11655 throw new Error("initializeWasm() must be awaited first!");
11657 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
11658 return nativeResponseValue;
11660 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
11662 export function CResult_OutPointDecodeErrorZ_is_ok(o: number): boolean {
11663 if(!isWasmInitialized) {
11664 throw new Error("initializeWasm() must be awaited first!");
11666 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
11667 return nativeResponseValue;
11669 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
11671 export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
11672 if(!isWasmInitialized) {
11673 throw new Error("initializeWasm() must be awaited first!");
11675 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
11676 // debug statements here
11678 // uintptr_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
11680 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: number): number {
11681 if(!isWasmInitialized) {
11682 throw new Error("initializeWasm() must be awaited first!");
11684 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
11685 return nativeResponseValue;
11687 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
11689 export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
11690 if(!isWasmInitialized) {
11691 throw new Error("initializeWasm() must be awaited first!");
11693 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
11694 return nativeResponseValue;
11696 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
11698 export function COption_TypeZ_some(o: number): number {
11699 if(!isWasmInitialized) {
11700 throw new Error("initializeWasm() must be awaited first!");
11702 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
11703 return nativeResponseValue;
11705 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
11707 export function COption_TypeZ_none(): number {
11708 if(!isWasmInitialized) {
11709 throw new Error("initializeWasm() must be awaited first!");
11711 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
11712 return nativeResponseValue;
11714 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
11716 export function COption_TypeZ_free(_res: number): void {
11717 if(!isWasmInitialized) {
11718 throw new Error("initializeWasm() must be awaited first!");
11720 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
11721 // debug statements here
11723 // uintptr_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
11725 export function COption_TypeZ_clone_ptr(arg: number): number {
11726 if(!isWasmInitialized) {
11727 throw new Error("initializeWasm() must be awaited first!");
11729 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
11730 return nativeResponseValue;
11732 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
11734 export function COption_TypeZ_clone(orig: number): number {
11735 if(!isWasmInitialized) {
11736 throw new Error("initializeWasm() must be awaited first!");
11738 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
11739 return nativeResponseValue;
11741 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
11743 export function CResult_COption_TypeZDecodeErrorZ_ok(o: number): number {
11744 if(!isWasmInitialized) {
11745 throw new Error("initializeWasm() must be awaited first!");
11747 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
11748 return nativeResponseValue;
11750 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
11752 export function CResult_COption_TypeZDecodeErrorZ_err(e: number): number {
11753 if(!isWasmInitialized) {
11754 throw new Error("initializeWasm() must be awaited first!");
11756 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
11757 return nativeResponseValue;
11759 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
11761 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: number): boolean {
11762 if(!isWasmInitialized) {
11763 throw new Error("initializeWasm() must be awaited first!");
11765 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
11766 return nativeResponseValue;
11768 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
11770 export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
11771 if(!isWasmInitialized) {
11772 throw new Error("initializeWasm() must be awaited first!");
11774 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
11775 // debug statements here
11777 // uintptr_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
11779 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: number): number {
11780 if(!isWasmInitialized) {
11781 throw new Error("initializeWasm() must be awaited first!");
11783 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
11784 return nativeResponseValue;
11786 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
11788 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
11789 if(!isWasmInitialized) {
11790 throw new Error("initializeWasm() must be awaited first!");
11792 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
11793 return nativeResponseValue;
11795 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
11797 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): number {
11798 if(!isWasmInitialized) {
11799 throw new Error("initializeWasm() must be awaited first!");
11801 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
11802 return nativeResponseValue;
11804 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
11806 export function CResult_PaymentIdPaymentErrorZ_err(e: number): number {
11807 if(!isWasmInitialized) {
11808 throw new Error("initializeWasm() must be awaited first!");
11810 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
11811 return nativeResponseValue;
11813 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
11815 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: number): boolean {
11816 if(!isWasmInitialized) {
11817 throw new Error("initializeWasm() must be awaited first!");
11819 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
11820 return nativeResponseValue;
11822 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
11824 export function CResult_PaymentIdPaymentErrorZ_free(_res: number): void {
11825 if(!isWasmInitialized) {
11826 throw new Error("initializeWasm() must be awaited first!");
11828 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
11829 // debug statements here
11831 // uintptr_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
11833 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: number): number {
11834 if(!isWasmInitialized) {
11835 throw new Error("initializeWasm() must be awaited first!");
11837 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
11838 return nativeResponseValue;
11840 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
11842 export function CResult_PaymentIdPaymentErrorZ_clone(orig: number): number {
11843 if(!isWasmInitialized) {
11844 throw new Error("initializeWasm() must be awaited first!");
11846 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
11847 return nativeResponseValue;
11849 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
11851 export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): number {
11852 if(!isWasmInitialized) {
11853 throw new Error("initializeWasm() must be awaited first!");
11855 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
11856 return nativeResponseValue;
11858 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
11860 export function CResult_SiPrefixParseErrorZ_err(e: number): number {
11861 if(!isWasmInitialized) {
11862 throw new Error("initializeWasm() must be awaited first!");
11864 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
11865 return nativeResponseValue;
11867 // bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
11869 export function CResult_SiPrefixParseErrorZ_is_ok(o: number): boolean {
11870 if(!isWasmInitialized) {
11871 throw new Error("initializeWasm() must be awaited first!");
11873 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
11874 return nativeResponseValue;
11876 // void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
11878 export function CResult_SiPrefixParseErrorZ_free(_res: number): void {
11879 if(!isWasmInitialized) {
11880 throw new Error("initializeWasm() must be awaited first!");
11882 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
11883 // debug statements here
11885 // uintptr_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
11887 export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: number): number {
11888 if(!isWasmInitialized) {
11889 throw new Error("initializeWasm() must be awaited first!");
11891 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
11892 return nativeResponseValue;
11894 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
11896 export function CResult_SiPrefixParseErrorZ_clone(orig: number): number {
11897 if(!isWasmInitialized) {
11898 throw new Error("initializeWasm() must be awaited first!");
11900 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
11901 return nativeResponseValue;
11903 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
11905 export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: number): number {
11906 if(!isWasmInitialized) {
11907 throw new Error("initializeWasm() must be awaited first!");
11909 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
11910 return nativeResponseValue;
11912 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
11914 export function CResult_InvoiceParseOrSemanticErrorZ_err(e: number): number {
11915 if(!isWasmInitialized) {
11916 throw new Error("initializeWasm() must be awaited first!");
11918 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
11919 return nativeResponseValue;
11921 // bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
11923 export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: number): boolean {
11924 if(!isWasmInitialized) {
11925 throw new Error("initializeWasm() must be awaited first!");
11927 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
11928 return nativeResponseValue;
11930 // void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
11932 export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: number): void {
11933 if(!isWasmInitialized) {
11934 throw new Error("initializeWasm() must be awaited first!");
11936 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
11937 // debug statements here
11939 // uintptr_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
11941 export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: number): number {
11942 if(!isWasmInitialized) {
11943 throw new Error("initializeWasm() must be awaited first!");
11945 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
11946 return nativeResponseValue;
11948 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
11950 export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: number): number {
11951 if(!isWasmInitialized) {
11952 throw new Error("initializeWasm() must be awaited first!");
11954 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
11955 return nativeResponseValue;
11957 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
11959 export function CResult_SignedRawInvoiceParseErrorZ_ok(o: number): number {
11960 if(!isWasmInitialized) {
11961 throw new Error("initializeWasm() must be awaited first!");
11963 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
11964 return nativeResponseValue;
11966 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
11968 export function CResult_SignedRawInvoiceParseErrorZ_err(e: number): number {
11969 if(!isWasmInitialized) {
11970 throw new Error("initializeWasm() must be awaited first!");
11972 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
11973 return nativeResponseValue;
11975 // bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
11977 export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: number): boolean {
11978 if(!isWasmInitialized) {
11979 throw new Error("initializeWasm() must be awaited first!");
11981 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
11982 return nativeResponseValue;
11984 // void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
11986 export function CResult_SignedRawInvoiceParseErrorZ_free(_res: number): void {
11987 if(!isWasmInitialized) {
11988 throw new Error("initializeWasm() must be awaited first!");
11990 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
11991 // debug statements here
11993 // uintptr_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
11995 export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: number): number {
11996 if(!isWasmInitialized) {
11997 throw new Error("initializeWasm() must be awaited first!");
11999 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
12000 return nativeResponseValue;
12002 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
12004 export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: number): number {
12005 if(!isWasmInitialized) {
12006 throw new Error("initializeWasm() must be awaited first!");
12008 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
12009 return nativeResponseValue;
12011 // uintptr_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
12013 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: number): number {
12014 if(!isWasmInitialized) {
12015 throw new Error("initializeWasm() must be awaited first!");
12017 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
12018 return nativeResponseValue;
12020 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
12022 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: number): number {
12023 if(!isWasmInitialized) {
12024 throw new Error("initializeWasm() must be awaited first!");
12026 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
12027 return nativeResponseValue;
12029 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
12031 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: number, b: number, c: number): number {
12032 if(!isWasmInitialized) {
12033 throw new Error("initializeWasm() must be awaited first!");
12035 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
12036 return nativeResponseValue;
12038 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
12040 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: number): void {
12041 if(!isWasmInitialized) {
12042 throw new Error("initializeWasm() must be awaited first!");
12044 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
12045 // debug statements here
12047 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
12049 export function CResult_PayeePubKeyErrorZ_ok(o: number): number {
12050 if(!isWasmInitialized) {
12051 throw new Error("initializeWasm() must be awaited first!");
12053 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
12054 return nativeResponseValue;
12056 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
12058 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): number {
12059 if(!isWasmInitialized) {
12060 throw new Error("initializeWasm() must be awaited first!");
12062 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
12063 return nativeResponseValue;
12065 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
12067 export function CResult_PayeePubKeyErrorZ_is_ok(o: number): boolean {
12068 if(!isWasmInitialized) {
12069 throw new Error("initializeWasm() must be awaited first!");
12071 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
12072 return nativeResponseValue;
12074 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
12076 export function CResult_PayeePubKeyErrorZ_free(_res: number): void {
12077 if(!isWasmInitialized) {
12078 throw new Error("initializeWasm() must be awaited first!");
12080 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
12081 // debug statements here
12083 // uintptr_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
12085 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: number): number {
12086 if(!isWasmInitialized) {
12087 throw new Error("initializeWasm() must be awaited first!");
12089 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
12090 return nativeResponseValue;
12092 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
12094 export function CResult_PayeePubKeyErrorZ_clone(orig: number): number {
12095 if(!isWasmInitialized) {
12096 throw new Error("initializeWasm() must be awaited first!");
12098 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
12099 return nativeResponseValue;
12101 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
12103 export function CVec_PrivateRouteZ_free(_res: number): void {
12104 if(!isWasmInitialized) {
12105 throw new Error("initializeWasm() must be awaited first!");
12107 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
12108 // debug statements here
12110 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
12112 export function CResult_PositiveTimestampCreationErrorZ_ok(o: number): number {
12113 if(!isWasmInitialized) {
12114 throw new Error("initializeWasm() must be awaited first!");
12116 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
12117 return nativeResponseValue;
12119 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
12121 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): number {
12122 if(!isWasmInitialized) {
12123 throw new Error("initializeWasm() must be awaited first!");
12125 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
12126 return nativeResponseValue;
12128 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
12130 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: number): boolean {
12131 if(!isWasmInitialized) {
12132 throw new Error("initializeWasm() must be awaited first!");
12134 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
12135 return nativeResponseValue;
12137 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
12139 export function CResult_PositiveTimestampCreationErrorZ_free(_res: number): void {
12140 if(!isWasmInitialized) {
12141 throw new Error("initializeWasm() must be awaited first!");
12143 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
12144 // debug statements here
12146 // uintptr_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
12148 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: number): number {
12149 if(!isWasmInitialized) {
12150 throw new Error("initializeWasm() must be awaited first!");
12152 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
12153 return nativeResponseValue;
12155 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
12157 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: number): number {
12158 if(!isWasmInitialized) {
12159 throw new Error("initializeWasm() must be awaited first!");
12161 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
12162 return nativeResponseValue;
12164 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
12166 export function CResult_NoneSemanticErrorZ_ok(): number {
12167 if(!isWasmInitialized) {
12168 throw new Error("initializeWasm() must be awaited first!");
12170 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
12171 return nativeResponseValue;
12173 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
12175 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): number {
12176 if(!isWasmInitialized) {
12177 throw new Error("initializeWasm() must be awaited first!");
12179 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
12180 return nativeResponseValue;
12182 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
12184 export function CResult_NoneSemanticErrorZ_is_ok(o: number): boolean {
12185 if(!isWasmInitialized) {
12186 throw new Error("initializeWasm() must be awaited first!");
12188 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
12189 return nativeResponseValue;
12191 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
12193 export function CResult_NoneSemanticErrorZ_free(_res: number): void {
12194 if(!isWasmInitialized) {
12195 throw new Error("initializeWasm() must be awaited first!");
12197 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
12198 // debug statements here
12200 // uintptr_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
12202 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: number): number {
12203 if(!isWasmInitialized) {
12204 throw new Error("initializeWasm() must be awaited first!");
12206 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
12207 return nativeResponseValue;
12209 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
12211 export function CResult_NoneSemanticErrorZ_clone(orig: number): number {
12212 if(!isWasmInitialized) {
12213 throw new Error("initializeWasm() must be awaited first!");
12215 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
12216 return nativeResponseValue;
12218 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
12220 export function CResult_InvoiceSemanticErrorZ_ok(o: number): number {
12221 if(!isWasmInitialized) {
12222 throw new Error("initializeWasm() must be awaited first!");
12224 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
12225 return nativeResponseValue;
12227 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
12229 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): number {
12230 if(!isWasmInitialized) {
12231 throw new Error("initializeWasm() must be awaited first!");
12233 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
12234 return nativeResponseValue;
12236 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
12238 export function CResult_InvoiceSemanticErrorZ_is_ok(o: number): boolean {
12239 if(!isWasmInitialized) {
12240 throw new Error("initializeWasm() must be awaited first!");
12242 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
12243 return nativeResponseValue;
12245 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
12247 export function CResult_InvoiceSemanticErrorZ_free(_res: number): void {
12248 if(!isWasmInitialized) {
12249 throw new Error("initializeWasm() must be awaited first!");
12251 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
12252 // debug statements here
12254 // uintptr_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
12256 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: number): number {
12257 if(!isWasmInitialized) {
12258 throw new Error("initializeWasm() must be awaited first!");
12260 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
12261 return nativeResponseValue;
12263 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
12265 export function CResult_InvoiceSemanticErrorZ_clone(orig: number): number {
12266 if(!isWasmInitialized) {
12267 throw new Error("initializeWasm() must be awaited first!");
12269 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
12270 return nativeResponseValue;
12272 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
12274 export function CResult_DescriptionCreationErrorZ_ok(o: number): number {
12275 if(!isWasmInitialized) {
12276 throw new Error("initializeWasm() must be awaited first!");
12278 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
12279 return nativeResponseValue;
12281 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
12283 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): number {
12284 if(!isWasmInitialized) {
12285 throw new Error("initializeWasm() must be awaited first!");
12287 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
12288 return nativeResponseValue;
12290 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
12292 export function CResult_DescriptionCreationErrorZ_is_ok(o: number): boolean {
12293 if(!isWasmInitialized) {
12294 throw new Error("initializeWasm() must be awaited first!");
12296 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
12297 return nativeResponseValue;
12299 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
12301 export function CResult_DescriptionCreationErrorZ_free(_res: number): void {
12302 if(!isWasmInitialized) {
12303 throw new Error("initializeWasm() must be awaited first!");
12305 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
12306 // debug statements here
12308 // uintptr_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
12310 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: number): number {
12311 if(!isWasmInitialized) {
12312 throw new Error("initializeWasm() must be awaited first!");
12314 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
12315 return nativeResponseValue;
12317 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
12319 export function CResult_DescriptionCreationErrorZ_clone(orig: number): number {
12320 if(!isWasmInitialized) {
12321 throw new Error("initializeWasm() must be awaited first!");
12323 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
12324 return nativeResponseValue;
12326 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
12328 export function CResult_PrivateRouteCreationErrorZ_ok(o: number): number {
12329 if(!isWasmInitialized) {
12330 throw new Error("initializeWasm() must be awaited first!");
12332 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
12333 return nativeResponseValue;
12335 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
12337 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): number {
12338 if(!isWasmInitialized) {
12339 throw new Error("initializeWasm() must be awaited first!");
12341 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
12342 return nativeResponseValue;
12344 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
12346 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: number): boolean {
12347 if(!isWasmInitialized) {
12348 throw new Error("initializeWasm() must be awaited first!");
12350 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
12351 return nativeResponseValue;
12353 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
12355 export function CResult_PrivateRouteCreationErrorZ_free(_res: number): void {
12356 if(!isWasmInitialized) {
12357 throw new Error("initializeWasm() must be awaited first!");
12359 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
12360 // debug statements here
12362 // uintptr_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
12364 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: number): number {
12365 if(!isWasmInitialized) {
12366 throw new Error("initializeWasm() must be awaited first!");
12368 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
12369 return nativeResponseValue;
12371 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
12373 export function CResult_PrivateRouteCreationErrorZ_clone(orig: number): number {
12374 if(!isWasmInitialized) {
12375 throw new Error("initializeWasm() must be awaited first!");
12377 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
12378 return nativeResponseValue;
12380 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
12382 export function CResult_StringErrorZ_ok(o: number): number {
12383 if(!isWasmInitialized) {
12384 throw new Error("initializeWasm() must be awaited first!");
12386 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
12387 return nativeResponseValue;
12389 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
12391 export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
12392 if(!isWasmInitialized) {
12393 throw new Error("initializeWasm() must be awaited first!");
12395 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
12396 return nativeResponseValue;
12398 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
12400 export function CResult_StringErrorZ_is_ok(o: number): boolean {
12401 if(!isWasmInitialized) {
12402 throw new Error("initializeWasm() must be awaited first!");
12404 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
12405 return nativeResponseValue;
12407 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
12409 export function CResult_StringErrorZ_free(_res: number): void {
12410 if(!isWasmInitialized) {
12411 throw new Error("initializeWasm() must be awaited first!");
12413 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
12414 // debug statements here
12416 // uintptr_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg);
12418 export function CResult_StringErrorZ_clone_ptr(arg: number): number {
12419 if(!isWasmInitialized) {
12420 throw new Error("initializeWasm() must be awaited first!");
12422 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone_ptr(arg);
12423 return nativeResponseValue;
12425 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_clone(const struct LDKCResult_StringErrorZ *NONNULL_PTR orig);
12427 export function CResult_StringErrorZ_clone(orig: number): number {
12428 if(!isWasmInitialized) {
12429 throw new Error("initializeWasm() must be awaited first!");
12431 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
12432 return nativeResponseValue;
12434 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
12436 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
12437 if(!isWasmInitialized) {
12438 throw new Error("initializeWasm() must be awaited first!");
12440 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
12441 return nativeResponseValue;
12443 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12445 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
12446 if(!isWasmInitialized) {
12447 throw new Error("initializeWasm() must be awaited first!");
12449 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
12450 return nativeResponseValue;
12452 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
12454 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: number): boolean {
12455 if(!isWasmInitialized) {
12456 throw new Error("initializeWasm() must be awaited first!");
12458 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
12459 return nativeResponseValue;
12461 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
12463 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
12464 if(!isWasmInitialized) {
12465 throw new Error("initializeWasm() must be awaited first!");
12467 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
12468 // debug statements here
12470 // uintptr_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
12472 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: number): number {
12473 if(!isWasmInitialized) {
12474 throw new Error("initializeWasm() must be awaited first!");
12476 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
12477 return nativeResponseValue;
12479 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
12481 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
12482 if(!isWasmInitialized) {
12483 throw new Error("initializeWasm() must be awaited first!");
12485 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
12486 return nativeResponseValue;
12488 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
12490 export function COption_MonitorEventZ_some(o: number): number {
12491 if(!isWasmInitialized) {
12492 throw new Error("initializeWasm() must be awaited first!");
12494 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
12495 return nativeResponseValue;
12497 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
12499 export function COption_MonitorEventZ_none(): number {
12500 if(!isWasmInitialized) {
12501 throw new Error("initializeWasm() must be awaited first!");
12503 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
12504 return nativeResponseValue;
12506 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
12508 export function COption_MonitorEventZ_free(_res: number): void {
12509 if(!isWasmInitialized) {
12510 throw new Error("initializeWasm() must be awaited first!");
12512 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
12513 // debug statements here
12515 // uintptr_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
12517 export function COption_MonitorEventZ_clone_ptr(arg: number): number {
12518 if(!isWasmInitialized) {
12519 throw new Error("initializeWasm() must be awaited first!");
12521 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
12522 return nativeResponseValue;
12524 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
12526 export function COption_MonitorEventZ_clone(orig: number): number {
12527 if(!isWasmInitialized) {
12528 throw new Error("initializeWasm() must be awaited first!");
12530 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
12531 return nativeResponseValue;
12533 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
12535 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: number): number {
12536 if(!isWasmInitialized) {
12537 throw new Error("initializeWasm() must be awaited first!");
12539 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
12540 return nativeResponseValue;
12542 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
12544 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: number): number {
12545 if(!isWasmInitialized) {
12546 throw new Error("initializeWasm() must be awaited first!");
12548 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
12549 return nativeResponseValue;
12551 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
12553 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: number): boolean {
12554 if(!isWasmInitialized) {
12555 throw new Error("initializeWasm() must be awaited first!");
12557 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
12558 return nativeResponseValue;
12560 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
12562 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: number): void {
12563 if(!isWasmInitialized) {
12564 throw new Error("initializeWasm() must be awaited first!");
12566 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
12567 // debug statements here
12569 // uintptr_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
12571 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: number): number {
12572 if(!isWasmInitialized) {
12573 throw new Error("initializeWasm() must be awaited first!");
12575 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
12576 return nativeResponseValue;
12578 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
12580 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: number): number {
12581 if(!isWasmInitialized) {
12582 throw new Error("initializeWasm() must be awaited first!");
12584 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
12585 return nativeResponseValue;
12587 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
12589 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
12590 if(!isWasmInitialized) {
12591 throw new Error("initializeWasm() must be awaited first!");
12593 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
12594 return nativeResponseValue;
12596 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12598 export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
12599 if(!isWasmInitialized) {
12600 throw new Error("initializeWasm() must be awaited first!");
12602 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
12603 return nativeResponseValue;
12605 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
12607 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: number): boolean {
12608 if(!isWasmInitialized) {
12609 throw new Error("initializeWasm() must be awaited first!");
12611 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
12612 return nativeResponseValue;
12614 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
12616 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
12617 if(!isWasmInitialized) {
12618 throw new Error("initializeWasm() must be awaited first!");
12620 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
12621 // debug statements here
12623 // uintptr_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
12625 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: number): number {
12626 if(!isWasmInitialized) {
12627 throw new Error("initializeWasm() must be awaited first!");
12629 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
12630 return nativeResponseValue;
12632 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
12634 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
12635 if(!isWasmInitialized) {
12636 throw new Error("initializeWasm() must be awaited first!");
12638 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
12639 return nativeResponseValue;
12641 // uintptr_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
12643 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: number): number {
12644 if(!isWasmInitialized) {
12645 throw new Error("initializeWasm() must be awaited first!");
12647 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
12648 return nativeResponseValue;
12650 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
12652 export function C2Tuple_OutPointScriptZ_clone(orig: number): number {
12653 if(!isWasmInitialized) {
12654 throw new Error("initializeWasm() must be awaited first!");
12656 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
12657 return nativeResponseValue;
12659 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
12661 export function C2Tuple_OutPointScriptZ_new(a: number, b: number): number {
12662 if(!isWasmInitialized) {
12663 throw new Error("initializeWasm() must be awaited first!");
12665 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
12666 return nativeResponseValue;
12668 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
12670 export function C2Tuple_OutPointScriptZ_free(_res: number): void {
12671 if(!isWasmInitialized) {
12672 throw new Error("initializeWasm() must be awaited first!");
12674 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
12675 // debug statements here
12677 // uintptr_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
12679 export function C2Tuple_u32ScriptZ_clone_ptr(arg: number): number {
12680 if(!isWasmInitialized) {
12681 throw new Error("initializeWasm() must be awaited first!");
12683 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
12684 return nativeResponseValue;
12686 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
12688 export function C2Tuple_u32ScriptZ_clone(orig: number): number {
12689 if(!isWasmInitialized) {
12690 throw new Error("initializeWasm() must be awaited first!");
12692 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
12693 return nativeResponseValue;
12695 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
12697 export function C2Tuple_u32ScriptZ_new(a: number, b: number): number {
12698 if(!isWasmInitialized) {
12699 throw new Error("initializeWasm() must be awaited first!");
12701 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
12702 return nativeResponseValue;
12704 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
12706 export function C2Tuple_u32ScriptZ_free(_res: number): void {
12707 if(!isWasmInitialized) {
12708 throw new Error("initializeWasm() must be awaited first!");
12710 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
12711 // debug statements here
12713 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
12715 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
12716 if(!isWasmInitialized) {
12717 throw new Error("initializeWasm() must be awaited first!");
12719 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
12720 // debug statements here
12722 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
12724 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: number): number {
12725 if(!isWasmInitialized) {
12726 throw new Error("initializeWasm() must be awaited first!");
12728 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
12729 return nativeResponseValue;
12731 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
12733 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: number): number {
12734 if(!isWasmInitialized) {
12735 throw new Error("initializeWasm() must be awaited first!");
12737 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
12738 return nativeResponseValue;
12740 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
12742 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): number {
12743 if(!isWasmInitialized) {
12744 throw new Error("initializeWasm() must be awaited first!");
12746 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
12747 return nativeResponseValue;
12749 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
12751 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: number): void {
12752 if(!isWasmInitialized) {
12753 throw new Error("initializeWasm() must be awaited first!");
12755 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
12756 // debug statements here
12758 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
12760 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
12761 if(!isWasmInitialized) {
12762 throw new Error("initializeWasm() must be awaited first!");
12764 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
12765 // debug statements here
12767 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
12769 export function CVec_EventZ_free(_res: number): void {
12770 if(!isWasmInitialized) {
12771 throw new Error("initializeWasm() must be awaited first!");
12773 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
12774 // debug statements here
12776 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
12778 export function CVec_TransactionZ_free(_res: number): void {
12779 if(!isWasmInitialized) {
12780 throw new Error("initializeWasm() must be awaited first!");
12782 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
12783 // debug statements here
12785 // uintptr_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
12787 export function C2Tuple_u32TxOutZ_clone_ptr(arg: number): number {
12788 if(!isWasmInitialized) {
12789 throw new Error("initializeWasm() must be awaited first!");
12791 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
12792 return nativeResponseValue;
12794 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
12796 export function C2Tuple_u32TxOutZ_clone(orig: number): number {
12797 if(!isWasmInitialized) {
12798 throw new Error("initializeWasm() must be awaited first!");
12800 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
12801 return nativeResponseValue;
12803 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
12805 export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
12806 if(!isWasmInitialized) {
12807 throw new Error("initializeWasm() must be awaited first!");
12809 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
12810 return nativeResponseValue;
12812 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
12814 export function C2Tuple_u32TxOutZ_free(_res: number): void {
12815 if(!isWasmInitialized) {
12816 throw new Error("initializeWasm() must be awaited first!");
12818 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
12819 // debug statements here
12821 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
12823 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
12824 if(!isWasmInitialized) {
12825 throw new Error("initializeWasm() must be awaited first!");
12827 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
12828 // debug statements here
12830 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
12832 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: number): number {
12833 if(!isWasmInitialized) {
12834 throw new Error("initializeWasm() must be awaited first!");
12836 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
12837 return nativeResponseValue;
12839 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
12841 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: number): number {
12842 if(!isWasmInitialized) {
12843 throw new Error("initializeWasm() must be awaited first!");
12845 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
12846 return nativeResponseValue;
12848 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
12850 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): number {
12851 if(!isWasmInitialized) {
12852 throw new Error("initializeWasm() must be awaited first!");
12854 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
12855 return nativeResponseValue;
12857 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
12859 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
12860 if(!isWasmInitialized) {
12861 throw new Error("initializeWasm() must be awaited first!");
12863 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
12864 // debug statements here
12866 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
12868 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
12869 if(!isWasmInitialized) {
12870 throw new Error("initializeWasm() must be awaited first!");
12872 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
12873 // debug statements here
12875 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
12877 export function CVec_BalanceZ_free(_res: number): void {
12878 if(!isWasmInitialized) {
12879 throw new Error("initializeWasm() must be awaited first!");
12881 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
12882 // debug statements here
12884 // uintptr_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
12886 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: number): number {
12887 if(!isWasmInitialized) {
12888 throw new Error("initializeWasm() must be awaited first!");
12890 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
12891 return nativeResponseValue;
12893 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
12895 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
12896 if(!isWasmInitialized) {
12897 throw new Error("initializeWasm() must be awaited first!");
12899 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
12900 return nativeResponseValue;
12902 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
12904 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: number): number {
12905 if(!isWasmInitialized) {
12906 throw new Error("initializeWasm() must be awaited first!");
12908 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
12909 return nativeResponseValue;
12911 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
12913 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
12914 if(!isWasmInitialized) {
12915 throw new Error("initializeWasm() must be awaited first!");
12917 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
12918 // debug statements here
12920 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
12922 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
12923 if(!isWasmInitialized) {
12924 throw new Error("initializeWasm() must be awaited first!");
12926 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
12927 return nativeResponseValue;
12929 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
12931 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
12932 if(!isWasmInitialized) {
12933 throw new Error("initializeWasm() must be awaited first!");
12935 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
12936 return nativeResponseValue;
12938 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
12940 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: number): boolean {
12941 if(!isWasmInitialized) {
12942 throw new Error("initializeWasm() must be awaited first!");
12944 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
12945 return nativeResponseValue;
12947 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
12949 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
12950 if(!isWasmInitialized) {
12951 throw new Error("initializeWasm() must be awaited first!");
12953 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
12954 // debug statements here
12956 // uintptr_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
12958 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: number): number {
12959 if(!isWasmInitialized) {
12960 throw new Error("initializeWasm() must be awaited first!");
12962 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
12963 return nativeResponseValue;
12965 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
12967 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
12968 if(!isWasmInitialized) {
12969 throw new Error("initializeWasm() must be awaited first!");
12971 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
12972 return nativeResponseValue;
12974 // uintptr_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
12976 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: number): number {
12977 if(!isWasmInitialized) {
12978 throw new Error("initializeWasm() must be awaited first!");
12980 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
12981 return nativeResponseValue;
12983 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
12985 export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
12986 if(!isWasmInitialized) {
12987 throw new Error("initializeWasm() must be awaited first!");
12989 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
12990 return nativeResponseValue;
12992 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
12994 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: number): number {
12995 if(!isWasmInitialized) {
12996 throw new Error("initializeWasm() must be awaited first!");
12998 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
12999 return nativeResponseValue;
13001 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
13003 export function C2Tuple_PublicKeyTypeZ_free(_res: number): void {
13004 if(!isWasmInitialized) {
13005 throw new Error("initializeWasm() must be awaited first!");
13007 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
13008 // debug statements here
13010 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
13012 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
13013 if(!isWasmInitialized) {
13014 throw new Error("initializeWasm() must be awaited first!");
13016 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
13017 // debug statements here
13019 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
13021 export function COption_NetAddressZ_some(o: number): number {
13022 if(!isWasmInitialized) {
13023 throw new Error("initializeWasm() must be awaited first!");
13025 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
13026 return nativeResponseValue;
13028 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
13030 export function COption_NetAddressZ_none(): number {
13031 if(!isWasmInitialized) {
13032 throw new Error("initializeWasm() must be awaited first!");
13034 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
13035 return nativeResponseValue;
13037 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
13039 export function COption_NetAddressZ_free(_res: number): void {
13040 if(!isWasmInitialized) {
13041 throw new Error("initializeWasm() must be awaited first!");
13043 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
13044 // debug statements here
13046 // uintptr_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
13048 export function COption_NetAddressZ_clone_ptr(arg: number): number {
13049 if(!isWasmInitialized) {
13050 throw new Error("initializeWasm() must be awaited first!");
13052 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
13053 return nativeResponseValue;
13055 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
13057 export function COption_NetAddressZ_clone(orig: number): number {
13058 if(!isWasmInitialized) {
13059 throw new Error("initializeWasm() must be awaited first!");
13061 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
13062 return nativeResponseValue;
13064 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
13066 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): number {
13067 if(!isWasmInitialized) {
13068 throw new Error("initializeWasm() must be awaited first!");
13070 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
13071 return nativeResponseValue;
13073 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
13075 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
13076 if(!isWasmInitialized) {
13077 throw new Error("initializeWasm() must be awaited first!");
13079 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
13080 return nativeResponseValue;
13082 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
13084 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: number): boolean {
13085 if(!isWasmInitialized) {
13086 throw new Error("initializeWasm() must be awaited first!");
13088 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
13089 return nativeResponseValue;
13091 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
13093 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
13094 if(!isWasmInitialized) {
13095 throw new Error("initializeWasm() must be awaited first!");
13097 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
13098 // debug statements here
13100 // uintptr_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
13102 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: number): number {
13103 if(!isWasmInitialized) {
13104 throw new Error("initializeWasm() must be awaited first!");
13106 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
13107 return nativeResponseValue;
13109 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
13111 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
13112 if(!isWasmInitialized) {
13113 throw new Error("initializeWasm() must be awaited first!");
13115 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
13116 return nativeResponseValue;
13118 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
13120 export function CResult_NonePeerHandleErrorZ_ok(): number {
13121 if(!isWasmInitialized) {
13122 throw new Error("initializeWasm() must be awaited first!");
13124 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
13125 return nativeResponseValue;
13127 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
13129 export function CResult_NonePeerHandleErrorZ_err(e: number): number {
13130 if(!isWasmInitialized) {
13131 throw new Error("initializeWasm() must be awaited first!");
13133 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
13134 return nativeResponseValue;
13136 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
13138 export function CResult_NonePeerHandleErrorZ_is_ok(o: number): boolean {
13139 if(!isWasmInitialized) {
13140 throw new Error("initializeWasm() must be awaited first!");
13142 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
13143 return nativeResponseValue;
13145 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
13147 export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
13148 if(!isWasmInitialized) {
13149 throw new Error("initializeWasm() must be awaited first!");
13151 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
13152 // debug statements here
13154 // uintptr_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
13156 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: number): number {
13157 if(!isWasmInitialized) {
13158 throw new Error("initializeWasm() must be awaited first!");
13160 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
13161 return nativeResponseValue;
13163 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
13165 export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
13166 if(!isWasmInitialized) {
13167 throw new Error("initializeWasm() must be awaited first!");
13169 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
13170 return nativeResponseValue;
13172 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
13174 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
13175 if(!isWasmInitialized) {
13176 throw new Error("initializeWasm() must be awaited first!");
13178 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
13179 return nativeResponseValue;
13181 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
13183 export function CResult_boolPeerHandleErrorZ_err(e: number): number {
13184 if(!isWasmInitialized) {
13185 throw new Error("initializeWasm() must be awaited first!");
13187 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
13188 return nativeResponseValue;
13190 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
13192 export function CResult_boolPeerHandleErrorZ_is_ok(o: number): boolean {
13193 if(!isWasmInitialized) {
13194 throw new Error("initializeWasm() must be awaited first!");
13196 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
13197 return nativeResponseValue;
13199 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
13201 export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
13202 if(!isWasmInitialized) {
13203 throw new Error("initializeWasm() must be awaited first!");
13205 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
13206 // debug statements here
13208 // uintptr_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
13210 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: number): number {
13211 if(!isWasmInitialized) {
13212 throw new Error("initializeWasm() must be awaited first!");
13214 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
13215 return nativeResponseValue;
13217 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
13219 export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
13220 if(!isWasmInitialized) {
13221 throw new Error("initializeWasm() must be awaited first!");
13223 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
13224 return nativeResponseValue;
13226 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
13228 export function CResult_NoneErrorZ_ok(): number {
13229 if(!isWasmInitialized) {
13230 throw new Error("initializeWasm() must be awaited first!");
13232 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
13233 return nativeResponseValue;
13235 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
13237 export function CResult_NoneErrorZ_err(e: IOError): number {
13238 if(!isWasmInitialized) {
13239 throw new Error("initializeWasm() must be awaited first!");
13241 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
13242 return nativeResponseValue;
13244 // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
13246 export function CResult_NoneErrorZ_is_ok(o: number): boolean {
13247 if(!isWasmInitialized) {
13248 throw new Error("initializeWasm() must be awaited first!");
13250 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
13251 return nativeResponseValue;
13253 // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
13255 export function CResult_NoneErrorZ_free(_res: number): void {
13256 if(!isWasmInitialized) {
13257 throw new Error("initializeWasm() must be awaited first!");
13259 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
13260 // debug statements here
13262 // uintptr_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
13264 export function CResult_NoneErrorZ_clone_ptr(arg: number): number {
13265 if(!isWasmInitialized) {
13266 throw new Error("initializeWasm() must be awaited first!");
13268 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
13269 return nativeResponseValue;
13271 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
13273 export function CResult_NoneErrorZ_clone(orig: number): number {
13274 if(!isWasmInitialized) {
13275 throw new Error("initializeWasm() must be awaited first!");
13277 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
13278 return nativeResponseValue;
13280 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
13282 export function CResult_NetAddressDecodeErrorZ_ok(o: number): number {
13283 if(!isWasmInitialized) {
13284 throw new Error("initializeWasm() must be awaited first!");
13286 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
13287 return nativeResponseValue;
13289 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
13291 export function CResult_NetAddressDecodeErrorZ_err(e: number): number {
13292 if(!isWasmInitialized) {
13293 throw new Error("initializeWasm() must be awaited first!");
13295 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
13296 return nativeResponseValue;
13298 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
13300 export function CResult_NetAddressDecodeErrorZ_is_ok(o: number): boolean {
13301 if(!isWasmInitialized) {
13302 throw new Error("initializeWasm() must be awaited first!");
13304 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
13305 return nativeResponseValue;
13307 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
13309 export function CResult_NetAddressDecodeErrorZ_free(_res: number): void {
13310 if(!isWasmInitialized) {
13311 throw new Error("initializeWasm() must be awaited first!");
13313 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
13314 // debug statements here
13316 // uintptr_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
13318 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: number): number {
13319 if(!isWasmInitialized) {
13320 throw new Error("initializeWasm() must be awaited first!");
13322 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
13323 return nativeResponseValue;
13325 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
13327 export function CResult_NetAddressDecodeErrorZ_clone(orig: number): number {
13328 if(!isWasmInitialized) {
13329 throw new Error("initializeWasm() must be awaited first!");
13331 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
13332 return nativeResponseValue;
13334 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
13336 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
13337 if(!isWasmInitialized) {
13338 throw new Error("initializeWasm() must be awaited first!");
13340 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
13341 // debug statements here
13343 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
13345 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
13346 if(!isWasmInitialized) {
13347 throw new Error("initializeWasm() must be awaited first!");
13349 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
13350 // debug statements here
13352 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
13354 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
13355 if(!isWasmInitialized) {
13356 throw new Error("initializeWasm() must be awaited first!");
13358 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
13359 // debug statements here
13361 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
13363 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
13364 if(!isWasmInitialized) {
13365 throw new Error("initializeWasm() must be awaited first!");
13367 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
13368 // debug statements here
13370 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
13372 export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
13373 if(!isWasmInitialized) {
13374 throw new Error("initializeWasm() must be awaited first!");
13376 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
13377 return nativeResponseValue;
13379 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
13381 export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
13382 if(!isWasmInitialized) {
13383 throw new Error("initializeWasm() must be awaited first!");
13385 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
13386 return nativeResponseValue;
13388 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
13390 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: number): boolean {
13391 if(!isWasmInitialized) {
13392 throw new Error("initializeWasm() must be awaited first!");
13394 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
13395 return nativeResponseValue;
13397 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
13399 export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
13400 if(!isWasmInitialized) {
13401 throw new Error("initializeWasm() must be awaited first!");
13403 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
13404 // debug statements here
13406 // uintptr_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
13408 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: number): number {
13409 if(!isWasmInitialized) {
13410 throw new Error("initializeWasm() must be awaited first!");
13412 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
13413 return nativeResponseValue;
13415 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
13417 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
13418 if(!isWasmInitialized) {
13419 throw new Error("initializeWasm() must be awaited first!");
13421 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
13422 return nativeResponseValue;
13424 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
13426 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
13427 if(!isWasmInitialized) {
13428 throw new Error("initializeWasm() must be awaited first!");
13430 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
13431 return nativeResponseValue;
13433 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
13435 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
13436 if(!isWasmInitialized) {
13437 throw new Error("initializeWasm() must be awaited first!");
13439 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
13440 return nativeResponseValue;
13442 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
13444 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: number): boolean {
13445 if(!isWasmInitialized) {
13446 throw new Error("initializeWasm() must be awaited first!");
13448 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
13449 return nativeResponseValue;
13451 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
13453 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
13454 if(!isWasmInitialized) {
13455 throw new Error("initializeWasm() must be awaited first!");
13457 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
13458 // debug statements here
13460 // uintptr_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
13462 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: number): number {
13463 if(!isWasmInitialized) {
13464 throw new Error("initializeWasm() must be awaited first!");
13466 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
13467 return nativeResponseValue;
13469 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
13471 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
13472 if(!isWasmInitialized) {
13473 throw new Error("initializeWasm() must be awaited first!");
13475 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
13476 return nativeResponseValue;
13478 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
13480 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
13481 if(!isWasmInitialized) {
13482 throw new Error("initializeWasm() must be awaited first!");
13484 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
13485 return nativeResponseValue;
13487 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
13489 export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
13490 if(!isWasmInitialized) {
13491 throw new Error("initializeWasm() must be awaited first!");
13493 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
13494 return nativeResponseValue;
13496 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
13498 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: number): boolean {
13499 if(!isWasmInitialized) {
13500 throw new Error("initializeWasm() must be awaited first!");
13502 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
13503 return nativeResponseValue;
13505 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
13507 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
13508 if(!isWasmInitialized) {
13509 throw new Error("initializeWasm() must be awaited first!");
13511 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
13512 // debug statements here
13514 // uintptr_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
13516 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: number): number {
13517 if(!isWasmInitialized) {
13518 throw new Error("initializeWasm() must be awaited first!");
13520 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
13521 return nativeResponseValue;
13523 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
13525 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
13526 if(!isWasmInitialized) {
13527 throw new Error("initializeWasm() must be awaited first!");
13529 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
13530 return nativeResponseValue;
13532 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
13534 export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
13535 if(!isWasmInitialized) {
13536 throw new Error("initializeWasm() must be awaited first!");
13538 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
13539 return nativeResponseValue;
13541 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13543 export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
13544 if(!isWasmInitialized) {
13545 throw new Error("initializeWasm() must be awaited first!");
13547 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
13548 return nativeResponseValue;
13550 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
13552 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: number): boolean {
13553 if(!isWasmInitialized) {
13554 throw new Error("initializeWasm() must be awaited first!");
13556 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
13557 return nativeResponseValue;
13559 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
13561 export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
13562 if(!isWasmInitialized) {
13563 throw new Error("initializeWasm() must be awaited first!");
13565 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
13566 // debug statements here
13568 // uintptr_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
13570 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: number): number {
13571 if(!isWasmInitialized) {
13572 throw new Error("initializeWasm() must be awaited first!");
13574 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
13575 return nativeResponseValue;
13577 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
13579 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
13580 if(!isWasmInitialized) {
13581 throw new Error("initializeWasm() must be awaited first!");
13583 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
13584 return nativeResponseValue;
13586 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
13588 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: number): number {
13589 if(!isWasmInitialized) {
13590 throw new Error("initializeWasm() must be awaited first!");
13592 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
13593 return nativeResponseValue;
13595 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
13597 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: number): number {
13598 if(!isWasmInitialized) {
13599 throw new Error("initializeWasm() must be awaited first!");
13601 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
13602 return nativeResponseValue;
13604 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
13606 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: number): boolean {
13607 if(!isWasmInitialized) {
13608 throw new Error("initializeWasm() must be awaited first!");
13610 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
13611 return nativeResponseValue;
13613 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
13615 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
13616 if(!isWasmInitialized) {
13617 throw new Error("initializeWasm() must be awaited first!");
13619 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
13620 // debug statements here
13622 // uintptr_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
13624 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: number): number {
13625 if(!isWasmInitialized) {
13626 throw new Error("initializeWasm() must be awaited first!");
13628 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
13629 return nativeResponseValue;
13631 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
13633 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
13634 if(!isWasmInitialized) {
13635 throw new Error("initializeWasm() must be awaited first!");
13637 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
13638 return nativeResponseValue;
13640 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
13642 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
13643 if(!isWasmInitialized) {
13644 throw new Error("initializeWasm() must be awaited first!");
13646 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
13647 return nativeResponseValue;
13649 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
13651 export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
13652 if(!isWasmInitialized) {
13653 throw new Error("initializeWasm() must be awaited first!");
13655 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
13656 return nativeResponseValue;
13658 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
13660 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: number): boolean {
13661 if(!isWasmInitialized) {
13662 throw new Error("initializeWasm() must be awaited first!");
13664 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
13665 return nativeResponseValue;
13667 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
13669 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
13670 if(!isWasmInitialized) {
13671 throw new Error("initializeWasm() must be awaited first!");
13673 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
13674 // debug statements here
13676 // uintptr_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
13678 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: number): number {
13679 if(!isWasmInitialized) {
13680 throw new Error("initializeWasm() must be awaited first!");
13682 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
13683 return nativeResponseValue;
13685 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
13687 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
13688 if(!isWasmInitialized) {
13689 throw new Error("initializeWasm() must be awaited first!");
13691 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
13692 return nativeResponseValue;
13694 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
13696 export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
13697 if(!isWasmInitialized) {
13698 throw new Error("initializeWasm() must be awaited first!");
13700 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
13701 return nativeResponseValue;
13703 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
13705 export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
13706 if(!isWasmInitialized) {
13707 throw new Error("initializeWasm() must be awaited first!");
13709 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
13710 return nativeResponseValue;
13712 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
13714 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: number): boolean {
13715 if(!isWasmInitialized) {
13716 throw new Error("initializeWasm() must be awaited first!");
13718 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
13719 return nativeResponseValue;
13721 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
13723 export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
13724 if(!isWasmInitialized) {
13725 throw new Error("initializeWasm() must be awaited first!");
13727 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
13728 // debug statements here
13730 // uintptr_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
13732 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: number): number {
13733 if(!isWasmInitialized) {
13734 throw new Error("initializeWasm() must be awaited first!");
13736 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
13737 return nativeResponseValue;
13739 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
13741 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
13742 if(!isWasmInitialized) {
13743 throw new Error("initializeWasm() must be awaited first!");
13745 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
13746 return nativeResponseValue;
13748 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
13750 export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
13751 if(!isWasmInitialized) {
13752 throw new Error("initializeWasm() must be awaited first!");
13754 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
13755 return nativeResponseValue;
13757 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13759 export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
13760 if(!isWasmInitialized) {
13761 throw new Error("initializeWasm() must be awaited first!");
13763 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
13764 return nativeResponseValue;
13766 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
13768 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: number): boolean {
13769 if(!isWasmInitialized) {
13770 throw new Error("initializeWasm() must be awaited first!");
13772 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
13773 return nativeResponseValue;
13775 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
13777 export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
13778 if(!isWasmInitialized) {
13779 throw new Error("initializeWasm() must be awaited first!");
13781 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
13782 // debug statements here
13784 // uintptr_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
13786 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: number): number {
13787 if(!isWasmInitialized) {
13788 throw new Error("initializeWasm() must be awaited first!");
13790 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
13791 return nativeResponseValue;
13793 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
13795 export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
13796 if(!isWasmInitialized) {
13797 throw new Error("initializeWasm() must be awaited first!");
13799 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
13800 return nativeResponseValue;
13802 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
13804 export function CResult_ChannelReadyDecodeErrorZ_ok(o: number): number {
13805 if(!isWasmInitialized) {
13806 throw new Error("initializeWasm() must be awaited first!");
13808 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
13809 return nativeResponseValue;
13811 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
13813 export function CResult_ChannelReadyDecodeErrorZ_err(e: number): number {
13814 if(!isWasmInitialized) {
13815 throw new Error("initializeWasm() must be awaited first!");
13817 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
13818 return nativeResponseValue;
13820 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
13822 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: number): boolean {
13823 if(!isWasmInitialized) {
13824 throw new Error("initializeWasm() must be awaited first!");
13826 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
13827 return nativeResponseValue;
13829 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
13831 export function CResult_ChannelReadyDecodeErrorZ_free(_res: number): void {
13832 if(!isWasmInitialized) {
13833 throw new Error("initializeWasm() must be awaited first!");
13835 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
13836 // debug statements here
13838 // uintptr_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
13840 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: number): number {
13841 if(!isWasmInitialized) {
13842 throw new Error("initializeWasm() must be awaited first!");
13844 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
13845 return nativeResponseValue;
13847 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
13849 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: number): number {
13850 if(!isWasmInitialized) {
13851 throw new Error("initializeWasm() must be awaited first!");
13853 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
13854 return nativeResponseValue;
13856 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
13858 export function CResult_InitDecodeErrorZ_ok(o: number): number {
13859 if(!isWasmInitialized) {
13860 throw new Error("initializeWasm() must be awaited first!");
13862 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
13863 return nativeResponseValue;
13865 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
13867 export function CResult_InitDecodeErrorZ_err(e: number): number {
13868 if(!isWasmInitialized) {
13869 throw new Error("initializeWasm() must be awaited first!");
13871 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
13872 return nativeResponseValue;
13874 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
13876 export function CResult_InitDecodeErrorZ_is_ok(o: number): boolean {
13877 if(!isWasmInitialized) {
13878 throw new Error("initializeWasm() must be awaited first!");
13880 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
13881 return nativeResponseValue;
13883 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
13885 export function CResult_InitDecodeErrorZ_free(_res: number): void {
13886 if(!isWasmInitialized) {
13887 throw new Error("initializeWasm() must be awaited first!");
13889 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
13890 // debug statements here
13892 // uintptr_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
13894 export function CResult_InitDecodeErrorZ_clone_ptr(arg: number): number {
13895 if(!isWasmInitialized) {
13896 throw new Error("initializeWasm() must be awaited first!");
13898 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
13899 return nativeResponseValue;
13901 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
13903 export function CResult_InitDecodeErrorZ_clone(orig: number): number {
13904 if(!isWasmInitialized) {
13905 throw new Error("initializeWasm() must be awaited first!");
13907 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
13908 return nativeResponseValue;
13910 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
13912 export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
13913 if(!isWasmInitialized) {
13914 throw new Error("initializeWasm() must be awaited first!");
13916 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
13917 return nativeResponseValue;
13919 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
13921 export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
13922 if(!isWasmInitialized) {
13923 throw new Error("initializeWasm() must be awaited first!");
13925 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
13926 return nativeResponseValue;
13928 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
13930 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: number): boolean {
13931 if(!isWasmInitialized) {
13932 throw new Error("initializeWasm() must be awaited first!");
13934 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
13935 return nativeResponseValue;
13937 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
13939 export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
13940 if(!isWasmInitialized) {
13941 throw new Error("initializeWasm() must be awaited first!");
13943 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
13944 // debug statements here
13946 // uintptr_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
13948 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: number): number {
13949 if(!isWasmInitialized) {
13950 throw new Error("initializeWasm() must be awaited first!");
13952 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
13953 return nativeResponseValue;
13955 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
13957 export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
13958 if(!isWasmInitialized) {
13959 throw new Error("initializeWasm() must be awaited first!");
13961 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
13962 return nativeResponseValue;
13964 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
13966 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
13967 if(!isWasmInitialized) {
13968 throw new Error("initializeWasm() must be awaited first!");
13970 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
13971 return nativeResponseValue;
13973 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
13975 export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
13976 if(!isWasmInitialized) {
13977 throw new Error("initializeWasm() must be awaited first!");
13979 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
13980 return nativeResponseValue;
13982 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
13984 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: number): boolean {
13985 if(!isWasmInitialized) {
13986 throw new Error("initializeWasm() must be awaited first!");
13988 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
13989 return nativeResponseValue;
13991 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
13993 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
13994 if(!isWasmInitialized) {
13995 throw new Error("initializeWasm() must be awaited first!");
13997 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
13998 // debug statements here
14000 // uintptr_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
14002 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: number): number {
14003 if(!isWasmInitialized) {
14004 throw new Error("initializeWasm() must be awaited first!");
14006 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
14007 return nativeResponseValue;
14009 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
14011 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
14012 if(!isWasmInitialized) {
14013 throw new Error("initializeWasm() must be awaited first!");
14015 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
14016 return nativeResponseValue;
14018 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
14020 export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
14021 if(!isWasmInitialized) {
14022 throw new Error("initializeWasm() must be awaited first!");
14024 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
14025 return nativeResponseValue;
14027 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
14029 export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
14030 if(!isWasmInitialized) {
14031 throw new Error("initializeWasm() must be awaited first!");
14033 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
14034 return nativeResponseValue;
14036 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
14038 export function CResult_ShutdownDecodeErrorZ_is_ok(o: number): boolean {
14039 if(!isWasmInitialized) {
14040 throw new Error("initializeWasm() must be awaited first!");
14042 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
14043 return nativeResponseValue;
14045 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
14047 export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
14048 if(!isWasmInitialized) {
14049 throw new Error("initializeWasm() must be awaited first!");
14051 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
14052 // debug statements here
14054 // uintptr_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
14056 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: number): number {
14057 if(!isWasmInitialized) {
14058 throw new Error("initializeWasm() must be awaited first!");
14060 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
14061 return nativeResponseValue;
14063 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
14065 export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
14066 if(!isWasmInitialized) {
14067 throw new Error("initializeWasm() must be awaited first!");
14069 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
14070 return nativeResponseValue;
14072 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
14074 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
14075 if(!isWasmInitialized) {
14076 throw new Error("initializeWasm() must be awaited first!");
14078 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
14079 return nativeResponseValue;
14081 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14083 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
14084 if(!isWasmInitialized) {
14085 throw new Error("initializeWasm() must be awaited first!");
14087 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
14088 return nativeResponseValue;
14090 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
14092 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: number): boolean {
14093 if(!isWasmInitialized) {
14094 throw new Error("initializeWasm() must be awaited first!");
14096 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
14097 return nativeResponseValue;
14099 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
14101 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
14102 if(!isWasmInitialized) {
14103 throw new Error("initializeWasm() must be awaited first!");
14105 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
14106 // debug statements here
14108 // uintptr_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
14110 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14111 if(!isWasmInitialized) {
14112 throw new Error("initializeWasm() must be awaited first!");
14114 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
14115 return nativeResponseValue;
14117 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
14119 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
14120 if(!isWasmInitialized) {
14121 throw new Error("initializeWasm() must be awaited first!");
14123 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
14124 return nativeResponseValue;
14126 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
14128 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
14129 if(!isWasmInitialized) {
14130 throw new Error("initializeWasm() must be awaited first!");
14132 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
14133 return nativeResponseValue;
14135 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14137 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
14138 if(!isWasmInitialized) {
14139 throw new Error("initializeWasm() must be awaited first!");
14141 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
14142 return nativeResponseValue;
14144 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
14146 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: number): boolean {
14147 if(!isWasmInitialized) {
14148 throw new Error("initializeWasm() must be awaited first!");
14150 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
14151 return nativeResponseValue;
14153 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
14155 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
14156 if(!isWasmInitialized) {
14157 throw new Error("initializeWasm() must be awaited first!");
14159 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
14160 // debug statements here
14162 // uintptr_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
14164 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14165 if(!isWasmInitialized) {
14166 throw new Error("initializeWasm() must be awaited first!");
14168 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
14169 return nativeResponseValue;
14171 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
14173 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
14174 if(!isWasmInitialized) {
14175 throw new Error("initializeWasm() must be awaited first!");
14177 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
14178 return nativeResponseValue;
14180 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
14182 export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
14183 if(!isWasmInitialized) {
14184 throw new Error("initializeWasm() must be awaited first!");
14186 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
14187 return nativeResponseValue;
14189 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
14191 export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
14192 if(!isWasmInitialized) {
14193 throw new Error("initializeWasm() must be awaited first!");
14195 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
14196 return nativeResponseValue;
14198 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
14200 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: number): boolean {
14201 if(!isWasmInitialized) {
14202 throw new Error("initializeWasm() must be awaited first!");
14204 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
14205 return nativeResponseValue;
14207 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
14209 export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
14210 if(!isWasmInitialized) {
14211 throw new Error("initializeWasm() must be awaited first!");
14213 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
14214 // debug statements here
14216 // uintptr_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
14218 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: number): number {
14219 if(!isWasmInitialized) {
14220 throw new Error("initializeWasm() must be awaited first!");
14222 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
14223 return nativeResponseValue;
14225 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
14227 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
14228 if(!isWasmInitialized) {
14229 throw new Error("initializeWasm() must be awaited first!");
14231 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
14232 return nativeResponseValue;
14234 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
14236 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
14237 if(!isWasmInitialized) {
14238 throw new Error("initializeWasm() must be awaited first!");
14240 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
14241 return nativeResponseValue;
14243 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14245 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
14246 if(!isWasmInitialized) {
14247 throw new Error("initializeWasm() must be awaited first!");
14249 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
14250 return nativeResponseValue;
14252 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
14254 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: number): boolean {
14255 if(!isWasmInitialized) {
14256 throw new Error("initializeWasm() must be awaited first!");
14258 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
14259 return nativeResponseValue;
14261 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
14263 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
14264 if(!isWasmInitialized) {
14265 throw new Error("initializeWasm() must be awaited first!");
14267 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
14268 // debug statements here
14270 // uintptr_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
14272 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14273 if(!isWasmInitialized) {
14274 throw new Error("initializeWasm() must be awaited first!");
14276 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
14277 return nativeResponseValue;
14279 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
14281 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
14282 if(!isWasmInitialized) {
14283 throw new Error("initializeWasm() must be awaited first!");
14285 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
14286 return nativeResponseValue;
14288 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
14290 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
14291 if(!isWasmInitialized) {
14292 throw new Error("initializeWasm() must be awaited first!");
14294 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
14295 return nativeResponseValue;
14297 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14299 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
14300 if(!isWasmInitialized) {
14301 throw new Error("initializeWasm() must be awaited first!");
14303 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
14304 return nativeResponseValue;
14306 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
14308 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: number): boolean {
14309 if(!isWasmInitialized) {
14310 throw new Error("initializeWasm() must be awaited first!");
14312 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
14313 return nativeResponseValue;
14315 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
14317 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
14318 if(!isWasmInitialized) {
14319 throw new Error("initializeWasm() must be awaited first!");
14321 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
14322 // debug statements here
14324 // uintptr_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
14326 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14327 if(!isWasmInitialized) {
14328 throw new Error("initializeWasm() must be awaited first!");
14330 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
14331 return nativeResponseValue;
14333 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
14335 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
14336 if(!isWasmInitialized) {
14337 throw new Error("initializeWasm() must be awaited first!");
14339 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
14340 return nativeResponseValue;
14342 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
14344 export function CResult_PingDecodeErrorZ_ok(o: number): number {
14345 if(!isWasmInitialized) {
14346 throw new Error("initializeWasm() must be awaited first!");
14348 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
14349 return nativeResponseValue;
14351 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
14353 export function CResult_PingDecodeErrorZ_err(e: number): number {
14354 if(!isWasmInitialized) {
14355 throw new Error("initializeWasm() must be awaited first!");
14357 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
14358 return nativeResponseValue;
14360 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
14362 export function CResult_PingDecodeErrorZ_is_ok(o: number): boolean {
14363 if(!isWasmInitialized) {
14364 throw new Error("initializeWasm() must be awaited first!");
14366 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
14367 return nativeResponseValue;
14369 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
14371 export function CResult_PingDecodeErrorZ_free(_res: number): void {
14372 if(!isWasmInitialized) {
14373 throw new Error("initializeWasm() must be awaited first!");
14375 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
14376 // debug statements here
14378 // uintptr_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
14380 export function CResult_PingDecodeErrorZ_clone_ptr(arg: number): number {
14381 if(!isWasmInitialized) {
14382 throw new Error("initializeWasm() must be awaited first!");
14384 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
14385 return nativeResponseValue;
14387 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
14389 export function CResult_PingDecodeErrorZ_clone(orig: number): number {
14390 if(!isWasmInitialized) {
14391 throw new Error("initializeWasm() must be awaited first!");
14393 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
14394 return nativeResponseValue;
14396 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
14398 export function CResult_PongDecodeErrorZ_ok(o: number): number {
14399 if(!isWasmInitialized) {
14400 throw new Error("initializeWasm() must be awaited first!");
14402 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
14403 return nativeResponseValue;
14405 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
14407 export function CResult_PongDecodeErrorZ_err(e: number): number {
14408 if(!isWasmInitialized) {
14409 throw new Error("initializeWasm() must be awaited first!");
14411 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
14412 return nativeResponseValue;
14414 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
14416 export function CResult_PongDecodeErrorZ_is_ok(o: number): boolean {
14417 if(!isWasmInitialized) {
14418 throw new Error("initializeWasm() must be awaited first!");
14420 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
14421 return nativeResponseValue;
14423 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
14425 export function CResult_PongDecodeErrorZ_free(_res: number): void {
14426 if(!isWasmInitialized) {
14427 throw new Error("initializeWasm() must be awaited first!");
14429 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
14430 // debug statements here
14432 // uintptr_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
14434 export function CResult_PongDecodeErrorZ_clone_ptr(arg: number): number {
14435 if(!isWasmInitialized) {
14436 throw new Error("initializeWasm() must be awaited first!");
14438 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
14439 return nativeResponseValue;
14441 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
14443 export function CResult_PongDecodeErrorZ_clone(orig: number): number {
14444 if(!isWasmInitialized) {
14445 throw new Error("initializeWasm() must be awaited first!");
14447 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
14448 return nativeResponseValue;
14450 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
14452 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
14453 if(!isWasmInitialized) {
14454 throw new Error("initializeWasm() must be awaited first!");
14456 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
14457 return nativeResponseValue;
14459 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14461 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
14462 if(!isWasmInitialized) {
14463 throw new Error("initializeWasm() must be awaited first!");
14465 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
14466 return nativeResponseValue;
14468 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14470 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14471 if(!isWasmInitialized) {
14472 throw new Error("initializeWasm() must be awaited first!");
14474 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
14475 return nativeResponseValue;
14477 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
14479 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
14480 if(!isWasmInitialized) {
14481 throw new Error("initializeWasm() must be awaited first!");
14483 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
14484 // debug statements here
14486 // uintptr_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14488 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14489 if(!isWasmInitialized) {
14490 throw new Error("initializeWasm() must be awaited first!");
14492 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14493 return nativeResponseValue;
14495 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14497 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
14498 if(!isWasmInitialized) {
14499 throw new Error("initializeWasm() must be awaited first!");
14501 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
14502 return nativeResponseValue;
14504 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
14506 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
14507 if(!isWasmInitialized) {
14508 throw new Error("initializeWasm() must be awaited first!");
14510 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
14511 return nativeResponseValue;
14513 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14515 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
14516 if(!isWasmInitialized) {
14517 throw new Error("initializeWasm() must be awaited first!");
14519 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
14520 return nativeResponseValue;
14522 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14524 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14525 if(!isWasmInitialized) {
14526 throw new Error("initializeWasm() must be awaited first!");
14528 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
14529 return nativeResponseValue;
14531 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
14533 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
14534 if(!isWasmInitialized) {
14535 throw new Error("initializeWasm() must be awaited first!");
14537 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
14538 // debug statements here
14540 // uintptr_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14542 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14543 if(!isWasmInitialized) {
14544 throw new Error("initializeWasm() must be awaited first!");
14546 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14547 return nativeResponseValue;
14549 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14551 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
14552 if(!isWasmInitialized) {
14553 throw new Error("initializeWasm() must be awaited first!");
14555 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
14556 return nativeResponseValue;
14558 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
14560 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
14561 if(!isWasmInitialized) {
14562 throw new Error("initializeWasm() must be awaited first!");
14564 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
14565 return nativeResponseValue;
14567 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14569 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
14570 if(!isWasmInitialized) {
14571 throw new Error("initializeWasm() must be awaited first!");
14573 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
14574 return nativeResponseValue;
14576 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14578 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14579 if(!isWasmInitialized) {
14580 throw new Error("initializeWasm() must be awaited first!");
14582 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
14583 return nativeResponseValue;
14585 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
14587 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
14588 if(!isWasmInitialized) {
14589 throw new Error("initializeWasm() must be awaited first!");
14591 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
14592 // debug statements here
14594 // uintptr_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14596 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14597 if(!isWasmInitialized) {
14598 throw new Error("initializeWasm() must be awaited first!");
14600 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
14601 return nativeResponseValue;
14603 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14605 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
14606 if(!isWasmInitialized) {
14607 throw new Error("initializeWasm() must be awaited first!");
14609 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
14610 return nativeResponseValue;
14612 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
14614 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
14615 if(!isWasmInitialized) {
14616 throw new Error("initializeWasm() must be awaited first!");
14618 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
14619 return nativeResponseValue;
14621 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14623 export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
14624 if(!isWasmInitialized) {
14625 throw new Error("initializeWasm() must be awaited first!");
14627 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
14628 return nativeResponseValue;
14630 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14632 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14633 if(!isWasmInitialized) {
14634 throw new Error("initializeWasm() must be awaited first!");
14636 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
14637 return nativeResponseValue;
14639 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
14641 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
14642 if(!isWasmInitialized) {
14643 throw new Error("initializeWasm() must be awaited first!");
14645 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
14646 // debug statements here
14648 // uintptr_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14650 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14651 if(!isWasmInitialized) {
14652 throw new Error("initializeWasm() must be awaited first!");
14654 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
14655 return nativeResponseValue;
14657 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14659 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
14660 if(!isWasmInitialized) {
14661 throw new Error("initializeWasm() must be awaited first!");
14663 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
14664 return nativeResponseValue;
14666 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
14668 export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
14669 if(!isWasmInitialized) {
14670 throw new Error("initializeWasm() must be awaited first!");
14672 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
14673 return nativeResponseValue;
14675 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
14677 export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
14678 if(!isWasmInitialized) {
14679 throw new Error("initializeWasm() must be awaited first!");
14681 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
14682 return nativeResponseValue;
14684 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
14686 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: number): boolean {
14687 if(!isWasmInitialized) {
14688 throw new Error("initializeWasm() must be awaited first!");
14690 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
14691 return nativeResponseValue;
14693 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
14695 export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
14696 if(!isWasmInitialized) {
14697 throw new Error("initializeWasm() must be awaited first!");
14699 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
14700 // debug statements here
14702 // uintptr_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
14704 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: number): number {
14705 if(!isWasmInitialized) {
14706 throw new Error("initializeWasm() must be awaited first!");
14708 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
14709 return nativeResponseValue;
14711 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
14713 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
14714 if(!isWasmInitialized) {
14715 throw new Error("initializeWasm() must be awaited first!");
14717 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
14718 return nativeResponseValue;
14720 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
14722 export function CResult_WarningMessageDecodeErrorZ_ok(o: number): number {
14723 if(!isWasmInitialized) {
14724 throw new Error("initializeWasm() must be awaited first!");
14726 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
14727 return nativeResponseValue;
14729 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
14731 export function CResult_WarningMessageDecodeErrorZ_err(e: number): number {
14732 if(!isWasmInitialized) {
14733 throw new Error("initializeWasm() must be awaited first!");
14735 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
14736 return nativeResponseValue;
14738 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
14740 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: number): boolean {
14741 if(!isWasmInitialized) {
14742 throw new Error("initializeWasm() must be awaited first!");
14744 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
14745 return nativeResponseValue;
14747 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
14749 export function CResult_WarningMessageDecodeErrorZ_free(_res: number): void {
14750 if(!isWasmInitialized) {
14751 throw new Error("initializeWasm() must be awaited first!");
14753 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
14754 // debug statements here
14756 // uintptr_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
14758 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: number): number {
14759 if(!isWasmInitialized) {
14760 throw new Error("initializeWasm() must be awaited first!");
14762 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
14763 return nativeResponseValue;
14765 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
14767 export function CResult_WarningMessageDecodeErrorZ_clone(orig: number): number {
14768 if(!isWasmInitialized) {
14769 throw new Error("initializeWasm() must be awaited first!");
14771 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
14772 return nativeResponseValue;
14774 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
14776 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
14777 if(!isWasmInitialized) {
14778 throw new Error("initializeWasm() must be awaited first!");
14780 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
14781 return nativeResponseValue;
14783 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14785 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
14786 if(!isWasmInitialized) {
14787 throw new Error("initializeWasm() must be awaited first!");
14789 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
14790 return nativeResponseValue;
14792 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14794 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14795 if(!isWasmInitialized) {
14796 throw new Error("initializeWasm() must be awaited first!");
14798 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
14799 return nativeResponseValue;
14801 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
14803 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
14804 if(!isWasmInitialized) {
14805 throw new Error("initializeWasm() must be awaited first!");
14807 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
14808 // debug statements here
14810 // uintptr_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14812 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14813 if(!isWasmInitialized) {
14814 throw new Error("initializeWasm() must be awaited first!");
14816 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14817 return nativeResponseValue;
14819 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14821 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14822 if(!isWasmInitialized) {
14823 throw new Error("initializeWasm() must be awaited first!");
14825 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
14826 return nativeResponseValue;
14828 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
14830 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
14831 if(!isWasmInitialized) {
14832 throw new Error("initializeWasm() must be awaited first!");
14834 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
14835 return nativeResponseValue;
14837 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14839 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
14840 if(!isWasmInitialized) {
14841 throw new Error("initializeWasm() must be awaited first!");
14843 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
14844 return nativeResponseValue;
14846 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14848 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14849 if(!isWasmInitialized) {
14850 throw new Error("initializeWasm() must be awaited first!");
14852 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
14853 return nativeResponseValue;
14855 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
14857 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
14858 if(!isWasmInitialized) {
14859 throw new Error("initializeWasm() must be awaited first!");
14861 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
14862 // debug statements here
14864 // uintptr_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14866 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14867 if(!isWasmInitialized) {
14868 throw new Error("initializeWasm() must be awaited first!");
14870 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14871 return nativeResponseValue;
14873 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14875 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14876 if(!isWasmInitialized) {
14877 throw new Error("initializeWasm() must be awaited first!");
14879 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
14880 return nativeResponseValue;
14882 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
14884 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
14885 if(!isWasmInitialized) {
14886 throw new Error("initializeWasm() must be awaited first!");
14888 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
14889 return nativeResponseValue;
14891 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
14893 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
14894 if(!isWasmInitialized) {
14895 throw new Error("initializeWasm() must be awaited first!");
14897 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
14898 return nativeResponseValue;
14900 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
14902 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: number): boolean {
14903 if(!isWasmInitialized) {
14904 throw new Error("initializeWasm() must be awaited first!");
14906 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
14907 return nativeResponseValue;
14909 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
14911 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
14912 if(!isWasmInitialized) {
14913 throw new Error("initializeWasm() must be awaited first!");
14915 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
14916 // debug statements here
14918 // uintptr_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
14920 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: number): number {
14921 if(!isWasmInitialized) {
14922 throw new Error("initializeWasm() must be awaited first!");
14924 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
14925 return nativeResponseValue;
14927 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
14929 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
14930 if(!isWasmInitialized) {
14931 throw new Error("initializeWasm() must be awaited first!");
14933 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
14934 return nativeResponseValue;
14936 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
14938 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
14939 if(!isWasmInitialized) {
14940 throw new Error("initializeWasm() must be awaited first!");
14942 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
14943 return nativeResponseValue;
14945 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
14947 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
14948 if(!isWasmInitialized) {
14949 throw new Error("initializeWasm() must be awaited first!");
14951 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
14952 return nativeResponseValue;
14954 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
14956 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: number): boolean {
14957 if(!isWasmInitialized) {
14958 throw new Error("initializeWasm() must be awaited first!");
14960 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
14961 return nativeResponseValue;
14963 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
14965 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
14966 if(!isWasmInitialized) {
14967 throw new Error("initializeWasm() must be awaited first!");
14969 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
14970 // debug statements here
14972 // uintptr_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
14974 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: number): number {
14975 if(!isWasmInitialized) {
14976 throw new Error("initializeWasm() must be awaited first!");
14978 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
14979 return nativeResponseValue;
14981 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
14983 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
14984 if(!isWasmInitialized) {
14985 throw new Error("initializeWasm() must be awaited first!");
14987 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
14988 return nativeResponseValue;
14990 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
14992 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
14993 if(!isWasmInitialized) {
14994 throw new Error("initializeWasm() must be awaited first!");
14996 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
14997 return nativeResponseValue;
14999 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
15001 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
15002 if(!isWasmInitialized) {
15003 throw new Error("initializeWasm() must be awaited first!");
15005 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
15006 return nativeResponseValue;
15008 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
15010 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
15011 if(!isWasmInitialized) {
15012 throw new Error("initializeWasm() must be awaited first!");
15014 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
15015 return nativeResponseValue;
15017 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
15019 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
15020 if(!isWasmInitialized) {
15021 throw new Error("initializeWasm() must be awaited first!");
15023 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
15024 // debug statements here
15026 // uintptr_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
15028 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
15029 if(!isWasmInitialized) {
15030 throw new Error("initializeWasm() must be awaited first!");
15032 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
15033 return nativeResponseValue;
15035 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
15037 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
15038 if(!isWasmInitialized) {
15039 throw new Error("initializeWasm() must be awaited first!");
15041 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
15042 return nativeResponseValue;
15044 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
15046 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
15047 if(!isWasmInitialized) {
15048 throw new Error("initializeWasm() must be awaited first!");
15050 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
15051 return nativeResponseValue;
15053 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
15055 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
15056 if(!isWasmInitialized) {
15057 throw new Error("initializeWasm() must be awaited first!");
15059 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
15060 return nativeResponseValue;
15062 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
15064 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
15065 if(!isWasmInitialized) {
15066 throw new Error("initializeWasm() must be awaited first!");
15068 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
15069 return nativeResponseValue;
15071 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
15073 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
15074 if(!isWasmInitialized) {
15075 throw new Error("initializeWasm() must be awaited first!");
15077 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
15078 // debug statements here
15080 // uintptr_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
15082 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
15083 if(!isWasmInitialized) {
15084 throw new Error("initializeWasm() must be awaited first!");
15086 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
15087 return nativeResponseValue;
15089 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
15091 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
15092 if(!isWasmInitialized) {
15093 throw new Error("initializeWasm() must be awaited first!");
15095 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
15096 return nativeResponseValue;
15098 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
15100 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
15101 if(!isWasmInitialized) {
15102 throw new Error("initializeWasm() must be awaited first!");
15104 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
15105 return nativeResponseValue;
15107 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
15109 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
15110 if(!isWasmInitialized) {
15111 throw new Error("initializeWasm() must be awaited first!");
15113 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
15114 return nativeResponseValue;
15116 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
15118 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: number): boolean {
15119 if(!isWasmInitialized) {
15120 throw new Error("initializeWasm() must be awaited first!");
15122 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
15123 return nativeResponseValue;
15125 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
15127 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
15128 if(!isWasmInitialized) {
15129 throw new Error("initializeWasm() must be awaited first!");
15131 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
15132 // debug statements here
15134 // uintptr_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
15136 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: number): number {
15137 if(!isWasmInitialized) {
15138 throw new Error("initializeWasm() must be awaited first!");
15140 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
15141 return nativeResponseValue;
15143 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
15145 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
15146 if(!isWasmInitialized) {
15147 throw new Error("initializeWasm() must be awaited first!");
15149 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
15150 return nativeResponseValue;
15152 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
15154 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: number): number {
15155 if(!isWasmInitialized) {
15156 throw new Error("initializeWasm() must be awaited first!");
15158 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
15159 return nativeResponseValue;
15161 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
15163 export function CResult_InvoiceSignOrCreationErrorZ_err(e: number): number {
15164 if(!isWasmInitialized) {
15165 throw new Error("initializeWasm() must be awaited first!");
15167 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
15168 return nativeResponseValue;
15170 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
15172 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: number): boolean {
15173 if(!isWasmInitialized) {
15174 throw new Error("initializeWasm() must be awaited first!");
15176 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
15177 return nativeResponseValue;
15179 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
15181 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: number): void {
15182 if(!isWasmInitialized) {
15183 throw new Error("initializeWasm() must be awaited first!");
15185 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
15186 // debug statements here
15188 // uintptr_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
15190 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: number): number {
15191 if(!isWasmInitialized) {
15192 throw new Error("initializeWasm() must be awaited first!");
15194 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
15195 return nativeResponseValue;
15197 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
15199 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: number): number {
15200 if(!isWasmInitialized) {
15201 throw new Error("initializeWasm() must be awaited first!");
15203 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
15204 return nativeResponseValue;
15206 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
15208 export function COption_FilterZ_some(o: number): number {
15209 if(!isWasmInitialized) {
15210 throw new Error("initializeWasm() must be awaited first!");
15212 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
15213 return nativeResponseValue;
15215 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
15217 export function COption_FilterZ_none(): number {
15218 if(!isWasmInitialized) {
15219 throw new Error("initializeWasm() must be awaited first!");
15221 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
15222 return nativeResponseValue;
15224 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
15226 export function COption_FilterZ_free(_res: number): void {
15227 if(!isWasmInitialized) {
15228 throw new Error("initializeWasm() must be awaited first!");
15230 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
15231 // debug statements here
15233 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
15235 export function CResult_LockedChannelMonitorNoneZ_ok(o: number): number {
15236 if(!isWasmInitialized) {
15237 throw new Error("initializeWasm() must be awaited first!");
15239 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
15240 return nativeResponseValue;
15242 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
15244 export function CResult_LockedChannelMonitorNoneZ_err(): number {
15245 if(!isWasmInitialized) {
15246 throw new Error("initializeWasm() must be awaited first!");
15248 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
15249 return nativeResponseValue;
15251 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
15253 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: number): boolean {
15254 if(!isWasmInitialized) {
15255 throw new Error("initializeWasm() must be awaited first!");
15257 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
15258 return nativeResponseValue;
15260 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
15262 export function CResult_LockedChannelMonitorNoneZ_free(_res: number): void {
15263 if(!isWasmInitialized) {
15264 throw new Error("initializeWasm() must be awaited first!");
15266 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
15267 // debug statements here
15269 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
15271 export function CVec_OutPointZ_free(_res: number): void {
15272 if(!isWasmInitialized) {
15273 throw new Error("initializeWasm() must be awaited first!");
15275 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
15276 // debug statements here
15278 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
15280 export function PaymentPurpose_free(this_ptr: number): void {
15281 if(!isWasmInitialized) {
15282 throw new Error("initializeWasm() must be awaited first!");
15284 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
15285 // debug statements here
15287 // uintptr_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
15289 export function PaymentPurpose_clone_ptr(arg: number): number {
15290 if(!isWasmInitialized) {
15291 throw new Error("initializeWasm() must be awaited first!");
15293 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
15294 return nativeResponseValue;
15296 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
15298 export function PaymentPurpose_clone(orig: number): number {
15299 if(!isWasmInitialized) {
15300 throw new Error("initializeWasm() must be awaited first!");
15302 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
15303 return nativeResponseValue;
15305 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
15307 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): number {
15308 if(!isWasmInitialized) {
15309 throw new Error("initializeWasm() must be awaited first!");
15311 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
15312 return nativeResponseValue;
15314 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
15316 export function PaymentPurpose_spontaneous_payment(a: number): number {
15317 if(!isWasmInitialized) {
15318 throw new Error("initializeWasm() must be awaited first!");
15320 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
15321 return nativeResponseValue;
15323 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
15325 export function PaymentPurpose_write(obj: number): number {
15326 if(!isWasmInitialized) {
15327 throw new Error("initializeWasm() must be awaited first!");
15329 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
15330 return nativeResponseValue;
15332 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
15334 export function PaymentPurpose_read(ser: number): number {
15335 if(!isWasmInitialized) {
15336 throw new Error("initializeWasm() must be awaited first!");
15338 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
15339 return nativeResponseValue;
15341 // void ClosureReason_free(struct LDKClosureReason this_ptr);
15343 export function ClosureReason_free(this_ptr: number): void {
15344 if(!isWasmInitialized) {
15345 throw new Error("initializeWasm() must be awaited first!");
15347 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
15348 // debug statements here
15350 // uintptr_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
15352 export function ClosureReason_clone_ptr(arg: number): number {
15353 if(!isWasmInitialized) {
15354 throw new Error("initializeWasm() must be awaited first!");
15356 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
15357 return nativeResponseValue;
15359 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
15361 export function ClosureReason_clone(orig: number): number {
15362 if(!isWasmInitialized) {
15363 throw new Error("initializeWasm() must be awaited first!");
15365 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
15366 return nativeResponseValue;
15368 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
15370 export function ClosureReason_counterparty_force_closed(peer_msg: number): number {
15371 if(!isWasmInitialized) {
15372 throw new Error("initializeWasm() must be awaited first!");
15374 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
15375 return nativeResponseValue;
15377 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
15379 export function ClosureReason_holder_force_closed(): number {
15380 if(!isWasmInitialized) {
15381 throw new Error("initializeWasm() must be awaited first!");
15383 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
15384 return nativeResponseValue;
15386 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
15388 export function ClosureReason_cooperative_closure(): number {
15389 if(!isWasmInitialized) {
15390 throw new Error("initializeWasm() must be awaited first!");
15392 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
15393 return nativeResponseValue;
15395 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
15397 export function ClosureReason_commitment_tx_confirmed(): number {
15398 if(!isWasmInitialized) {
15399 throw new Error("initializeWasm() must be awaited first!");
15401 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
15402 return nativeResponseValue;
15404 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
15406 export function ClosureReason_funding_timed_out(): number {
15407 if(!isWasmInitialized) {
15408 throw new Error("initializeWasm() must be awaited first!");
15410 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
15411 return nativeResponseValue;
15413 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
15415 export function ClosureReason_processing_error(err: number): number {
15416 if(!isWasmInitialized) {
15417 throw new Error("initializeWasm() must be awaited first!");
15419 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
15420 return nativeResponseValue;
15422 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
15424 export function ClosureReason_disconnected_peer(): number {
15425 if(!isWasmInitialized) {
15426 throw new Error("initializeWasm() must be awaited first!");
15428 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
15429 return nativeResponseValue;
15431 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
15433 export function ClosureReason_outdated_channel_manager(): number {
15434 if(!isWasmInitialized) {
15435 throw new Error("initializeWasm() must be awaited first!");
15437 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
15438 return nativeResponseValue;
15440 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
15442 export function ClosureReason_write(obj: number): number {
15443 if(!isWasmInitialized) {
15444 throw new Error("initializeWasm() must be awaited first!");
15446 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
15447 return nativeResponseValue;
15449 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
15451 export function ClosureReason_read(ser: number): number {
15452 if(!isWasmInitialized) {
15453 throw new Error("initializeWasm() must be awaited first!");
15455 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
15456 return nativeResponseValue;
15458 // void Event_free(struct LDKEvent this_ptr);
15460 export function Event_free(this_ptr: number): void {
15461 if(!isWasmInitialized) {
15462 throw new Error("initializeWasm() must be awaited first!");
15464 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
15465 // debug statements here
15467 // uintptr_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
15469 export function Event_clone_ptr(arg: number): number {
15470 if(!isWasmInitialized) {
15471 throw new Error("initializeWasm() must be awaited first!");
15473 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
15474 return nativeResponseValue;
15476 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
15478 export function Event_clone(orig: number): number {
15479 if(!isWasmInitialized) {
15480 throw new Error("initializeWasm() must be awaited first!");
15482 const nativeResponseValue = wasm.TS_Event_clone(orig);
15483 return nativeResponseValue;
15485 // 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);
15487 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 {
15488 if(!isWasmInitialized) {
15489 throw new Error("initializeWasm() must be awaited first!");
15491 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
15492 return nativeResponseValue;
15494 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15496 export function Event_payment_received(payment_hash: number, amount_msat: bigint, purpose: number): number {
15497 if(!isWasmInitialized) {
15498 throw new Error("initializeWasm() must be awaited first!");
15500 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amount_msat, purpose);
15501 return nativeResponseValue;
15503 // struct LDKEvent Event_payment_claimed(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15505 export function Event_payment_claimed(payment_hash: number, amount_msat: bigint, purpose: number): number {
15506 if(!isWasmInitialized) {
15507 throw new Error("initializeWasm() must be awaited first!");
15509 const nativeResponseValue = wasm.TS_Event_payment_claimed(payment_hash, amount_msat, purpose);
15510 return nativeResponseValue;
15512 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
15514 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: number): number {
15515 if(!isWasmInitialized) {
15516 throw new Error("initializeWasm() must be awaited first!");
15518 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
15519 return nativeResponseValue;
15521 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
15523 export function Event_payment_failed(payment_id: number, payment_hash: number): number {
15524 if(!isWasmInitialized) {
15525 throw new Error("initializeWasm() must be awaited first!");
15527 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
15528 return nativeResponseValue;
15530 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
15532 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): number {
15533 if(!isWasmInitialized) {
15534 throw new Error("initializeWasm() must be awaited first!");
15536 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
15537 return nativeResponseValue;
15539 // 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);
15541 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 {
15542 if(!isWasmInitialized) {
15543 throw new Error("initializeWasm() must be awaited first!");
15545 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);
15546 return nativeResponseValue;
15548 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
15550 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): number {
15551 if(!isWasmInitialized) {
15552 throw new Error("initializeWasm() must be awaited first!");
15554 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
15555 return nativeResponseValue;
15557 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
15559 export function Event_spendable_outputs(outputs: number): number {
15560 if(!isWasmInitialized) {
15561 throw new Error("initializeWasm() must be awaited first!");
15563 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
15564 return nativeResponseValue;
15566 // 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);
15568 export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: number, claim_from_onchain_tx: boolean): number {
15569 if(!isWasmInitialized) {
15570 throw new Error("initializeWasm() must be awaited first!");
15572 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx);
15573 return nativeResponseValue;
15575 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
15577 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: number): number {
15578 if(!isWasmInitialized) {
15579 throw new Error("initializeWasm() must be awaited first!");
15581 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
15582 return nativeResponseValue;
15584 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
15586 export function Event_discard_funding(channel_id: number, transaction: number): number {
15587 if(!isWasmInitialized) {
15588 throw new Error("initializeWasm() must be awaited first!");
15590 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
15591 return nativeResponseValue;
15593 // 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);
15595 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: number): number {
15596 if(!isWasmInitialized) {
15597 throw new Error("initializeWasm() must be awaited first!");
15599 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
15600 return nativeResponseValue;
15602 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
15604 export function Event_write(obj: number): number {
15605 if(!isWasmInitialized) {
15606 throw new Error("initializeWasm() must be awaited first!");
15608 const nativeResponseValue = wasm.TS_Event_write(obj);
15609 return nativeResponseValue;
15611 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
15613 export function Event_read(ser: number): number {
15614 if(!isWasmInitialized) {
15615 throw new Error("initializeWasm() must be awaited first!");
15617 const nativeResponseValue = wasm.TS_Event_read(ser);
15618 return nativeResponseValue;
15620 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
15622 export function MessageSendEvent_free(this_ptr: number): void {
15623 if(!isWasmInitialized) {
15624 throw new Error("initializeWasm() must be awaited first!");
15626 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
15627 // debug statements here
15629 // uintptr_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
15631 export function MessageSendEvent_clone_ptr(arg: number): number {
15632 if(!isWasmInitialized) {
15633 throw new Error("initializeWasm() must be awaited first!");
15635 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
15636 return nativeResponseValue;
15638 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
15640 export function MessageSendEvent_clone(orig: number): number {
15641 if(!isWasmInitialized) {
15642 throw new Error("initializeWasm() must be awaited first!");
15644 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
15645 return nativeResponseValue;
15647 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
15649 export function MessageSendEvent_send_accept_channel(node_id: number, msg: number): number {
15650 if(!isWasmInitialized) {
15651 throw new Error("initializeWasm() must be awaited first!");
15653 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
15654 return nativeResponseValue;
15656 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
15658 export function MessageSendEvent_send_open_channel(node_id: number, msg: number): number {
15659 if(!isWasmInitialized) {
15660 throw new Error("initializeWasm() must be awaited first!");
15662 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
15663 return nativeResponseValue;
15665 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
15667 export function MessageSendEvent_send_funding_created(node_id: number, msg: number): number {
15668 if(!isWasmInitialized) {
15669 throw new Error("initializeWasm() must be awaited first!");
15671 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
15672 return nativeResponseValue;
15674 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
15676 export function MessageSendEvent_send_funding_signed(node_id: number, msg: number): number {
15677 if(!isWasmInitialized) {
15678 throw new Error("initializeWasm() must be awaited first!");
15680 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
15681 return nativeResponseValue;
15683 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
15685 export function MessageSendEvent_send_channel_ready(node_id: number, msg: number): number {
15686 if(!isWasmInitialized) {
15687 throw new Error("initializeWasm() must be awaited first!");
15689 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
15690 return nativeResponseValue;
15692 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
15694 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: number): number {
15695 if(!isWasmInitialized) {
15696 throw new Error("initializeWasm() must be awaited first!");
15698 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
15699 return nativeResponseValue;
15701 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
15703 export function MessageSendEvent_update_htlcs(node_id: number, updates: number): number {
15704 if(!isWasmInitialized) {
15705 throw new Error("initializeWasm() must be awaited first!");
15707 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
15708 return nativeResponseValue;
15710 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
15712 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: number): number {
15713 if(!isWasmInitialized) {
15714 throw new Error("initializeWasm() must be awaited first!");
15716 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
15717 return nativeResponseValue;
15719 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
15721 export function MessageSendEvent_send_closing_signed(node_id: number, msg: number): number {
15722 if(!isWasmInitialized) {
15723 throw new Error("initializeWasm() must be awaited first!");
15725 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
15726 return nativeResponseValue;
15728 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
15730 export function MessageSendEvent_send_shutdown(node_id: number, msg: number): number {
15731 if(!isWasmInitialized) {
15732 throw new Error("initializeWasm() must be awaited first!");
15734 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
15735 return nativeResponseValue;
15737 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
15739 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: number): number {
15740 if(!isWasmInitialized) {
15741 throw new Error("initializeWasm() must be awaited first!");
15743 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
15744 return nativeResponseValue;
15746 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
15748 export function MessageSendEvent_broadcast_channel_announcement(msg: number, update_msg: number): number {
15749 if(!isWasmInitialized) {
15750 throw new Error("initializeWasm() must be awaited first!");
15752 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
15753 return nativeResponseValue;
15755 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
15757 export function MessageSendEvent_broadcast_node_announcement(msg: number): number {
15758 if(!isWasmInitialized) {
15759 throw new Error("initializeWasm() must be awaited first!");
15761 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
15762 return nativeResponseValue;
15764 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
15766 export function MessageSendEvent_broadcast_channel_update(msg: number): number {
15767 if(!isWasmInitialized) {
15768 throw new Error("initializeWasm() must be awaited first!");
15770 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
15771 return nativeResponseValue;
15773 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
15775 export function MessageSendEvent_send_channel_update(node_id: number, msg: number): number {
15776 if(!isWasmInitialized) {
15777 throw new Error("initializeWasm() must be awaited first!");
15779 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
15780 return nativeResponseValue;
15782 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
15784 export function MessageSendEvent_handle_error(node_id: number, action: number): number {
15785 if(!isWasmInitialized) {
15786 throw new Error("initializeWasm() must be awaited first!");
15788 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
15789 return nativeResponseValue;
15791 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
15793 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: number): number {
15794 if(!isWasmInitialized) {
15795 throw new Error("initializeWasm() must be awaited first!");
15797 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
15798 return nativeResponseValue;
15800 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
15802 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: number): number {
15803 if(!isWasmInitialized) {
15804 throw new Error("initializeWasm() must be awaited first!");
15806 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
15807 return nativeResponseValue;
15809 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
15811 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: number): number {
15812 if(!isWasmInitialized) {
15813 throw new Error("initializeWasm() must be awaited first!");
15815 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
15816 return nativeResponseValue;
15818 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
15820 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: number): number {
15821 if(!isWasmInitialized) {
15822 throw new Error("initializeWasm() must be awaited first!");
15824 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
15825 return nativeResponseValue;
15827 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
15829 export function MessageSendEventsProvider_free(this_ptr: number): void {
15830 if(!isWasmInitialized) {
15831 throw new Error("initializeWasm() must be awaited first!");
15833 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
15834 // debug statements here
15836 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
15838 export function EventsProvider_free(this_ptr: number): void {
15839 if(!isWasmInitialized) {
15840 throw new Error("initializeWasm() must be awaited first!");
15842 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
15843 // debug statements here
15845 // void EventHandler_free(struct LDKEventHandler this_ptr);
15847 export function EventHandler_free(this_ptr: number): void {
15848 if(!isWasmInitialized) {
15849 throw new Error("initializeWasm() must be awaited first!");
15851 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
15852 // debug statements here
15854 // void APIError_free(struct LDKAPIError this_ptr);
15856 export function APIError_free(this_ptr: number): void {
15857 if(!isWasmInitialized) {
15858 throw new Error("initializeWasm() must be awaited first!");
15860 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
15861 // debug statements here
15863 // uintptr_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
15865 export function APIError_clone_ptr(arg: number): number {
15866 if(!isWasmInitialized) {
15867 throw new Error("initializeWasm() must be awaited first!");
15869 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
15870 return nativeResponseValue;
15872 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
15874 export function APIError_clone(orig: number): number {
15875 if(!isWasmInitialized) {
15876 throw new Error("initializeWasm() must be awaited first!");
15878 const nativeResponseValue = wasm.TS_APIError_clone(orig);
15879 return nativeResponseValue;
15881 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
15883 export function APIError_apimisuse_error(err: number): number {
15884 if(!isWasmInitialized) {
15885 throw new Error("initializeWasm() must be awaited first!");
15887 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
15888 return nativeResponseValue;
15890 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
15892 export function APIError_fee_rate_too_high(err: number, feerate: number): number {
15893 if(!isWasmInitialized) {
15894 throw new Error("initializeWasm() must be awaited first!");
15896 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
15897 return nativeResponseValue;
15899 // struct LDKAPIError APIError_route_error(struct LDKStr err);
15901 export function APIError_route_error(err: number): number {
15902 if(!isWasmInitialized) {
15903 throw new Error("initializeWasm() must be awaited first!");
15905 const nativeResponseValue = wasm.TS_APIError_route_error(err);
15906 return nativeResponseValue;
15908 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
15910 export function APIError_channel_unavailable(err: number): number {
15911 if(!isWasmInitialized) {
15912 throw new Error("initializeWasm() must be awaited first!");
15914 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
15915 return nativeResponseValue;
15917 // struct LDKAPIError APIError_monitor_update_failed(void);
15919 export function APIError_monitor_update_failed(): number {
15920 if(!isWasmInitialized) {
15921 throw new Error("initializeWasm() must be awaited first!");
15923 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
15924 return nativeResponseValue;
15926 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
15928 export function APIError_incompatible_shutdown_script(script: number): number {
15929 if(!isWasmInitialized) {
15930 throw new Error("initializeWasm() must be awaited first!");
15932 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
15933 return nativeResponseValue;
15935 // void BigSize_free(struct LDKBigSize this_obj);
15937 export function BigSize_free(this_obj: number): void {
15938 if(!isWasmInitialized) {
15939 throw new Error("initializeWasm() must be awaited first!");
15941 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
15942 // debug statements here
15944 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
15946 export function BigSize_get_a(this_ptr: number): bigint {
15947 if(!isWasmInitialized) {
15948 throw new Error("initializeWasm() must be awaited first!");
15950 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
15951 return nativeResponseValue;
15953 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
15955 export function BigSize_set_a(this_ptr: number, val: bigint): void {
15956 if(!isWasmInitialized) {
15957 throw new Error("initializeWasm() must be awaited first!");
15959 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
15960 // debug statements here
15962 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
15964 export function BigSize_new(a_arg: bigint): number {
15965 if(!isWasmInitialized) {
15966 throw new Error("initializeWasm() must be awaited first!");
15968 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
15969 return nativeResponseValue;
15971 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
15973 export function sign(msg: number, sk: number): number {
15974 if(!isWasmInitialized) {
15975 throw new Error("initializeWasm() must be awaited first!");
15977 const nativeResponseValue = wasm.TS_sign(msg, sk);
15978 return nativeResponseValue;
15980 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
15982 export function recover_pk(msg: number, sig: number): number {
15983 if(!isWasmInitialized) {
15984 throw new Error("initializeWasm() must be awaited first!");
15986 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
15987 return nativeResponseValue;
15989 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
15991 export function verify(msg: number, sig: number, pk: number): boolean {
15992 if(!isWasmInitialized) {
15993 throw new Error("initializeWasm() must be awaited first!");
15995 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
15996 return nativeResponseValue;
15998 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z data_without_signature);
16000 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
16001 if(!isWasmInitialized) {
16002 throw new Error("initializeWasm() must be awaited first!");
16004 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
16005 return nativeResponseValue;
16007 // void Persister_free(struct LDKPersister this_ptr);
16009 export function Persister_free(this_ptr: number): void {
16010 if(!isWasmInitialized) {
16011 throw new Error("initializeWasm() must be awaited first!");
16013 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
16014 // debug statements here
16016 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
16018 export function Level_clone(orig: number): Level {
16019 if(!isWasmInitialized) {
16020 throw new Error("initializeWasm() must be awaited first!");
16022 const nativeResponseValue = wasm.TS_Level_clone(orig);
16023 return nativeResponseValue;
16025 // enum LDKLevel Level_gossip(void);
16027 export function Level_gossip(): Level {
16028 if(!isWasmInitialized) {
16029 throw new Error("initializeWasm() must be awaited first!");
16031 const nativeResponseValue = wasm.TS_Level_gossip();
16032 return nativeResponseValue;
16034 // enum LDKLevel Level_trace(void);
16036 export function Level_trace(): Level {
16037 if(!isWasmInitialized) {
16038 throw new Error("initializeWasm() must be awaited first!");
16040 const nativeResponseValue = wasm.TS_Level_trace();
16041 return nativeResponseValue;
16043 // enum LDKLevel Level_debug(void);
16045 export function Level_debug(): Level {
16046 if(!isWasmInitialized) {
16047 throw new Error("initializeWasm() must be awaited first!");
16049 const nativeResponseValue = wasm.TS_Level_debug();
16050 return nativeResponseValue;
16052 // enum LDKLevel Level_info(void);
16054 export function Level_info(): Level {
16055 if(!isWasmInitialized) {
16056 throw new Error("initializeWasm() must be awaited first!");
16058 const nativeResponseValue = wasm.TS_Level_info();
16059 return nativeResponseValue;
16061 // enum LDKLevel Level_warn(void);
16063 export function Level_warn(): Level {
16064 if(!isWasmInitialized) {
16065 throw new Error("initializeWasm() must be awaited first!");
16067 const nativeResponseValue = wasm.TS_Level_warn();
16068 return nativeResponseValue;
16070 // enum LDKLevel Level_error(void);
16072 export function Level_error(): Level {
16073 if(!isWasmInitialized) {
16074 throw new Error("initializeWasm() must be awaited first!");
16076 const nativeResponseValue = wasm.TS_Level_error();
16077 return nativeResponseValue;
16079 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
16081 export function Level_eq(a: number, b: number): boolean {
16082 if(!isWasmInitialized) {
16083 throw new Error("initializeWasm() must be awaited first!");
16085 const nativeResponseValue = wasm.TS_Level_eq(a, b);
16086 return nativeResponseValue;
16088 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
16090 export function Level_hash(o: number): bigint {
16091 if(!isWasmInitialized) {
16092 throw new Error("initializeWasm() must be awaited first!");
16094 const nativeResponseValue = wasm.TS_Level_hash(o);
16095 return nativeResponseValue;
16097 // MUST_USE_RES enum LDKLevel Level_max(void);
16099 export function Level_max(): Level {
16100 if(!isWasmInitialized) {
16101 throw new Error("initializeWasm() must be awaited first!");
16103 const nativeResponseValue = wasm.TS_Level_max();
16104 return nativeResponseValue;
16106 // void Record_free(struct LDKRecord this_obj);
16108 export function Record_free(this_obj: number): void {
16109 if(!isWasmInitialized) {
16110 throw new Error("initializeWasm() must be awaited first!");
16112 const nativeResponseValue = wasm.TS_Record_free(this_obj);
16113 // debug statements here
16115 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
16117 export function Record_get_level(this_ptr: number): Level {
16118 if(!isWasmInitialized) {
16119 throw new Error("initializeWasm() must be awaited first!");
16121 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
16122 return nativeResponseValue;
16124 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
16126 export function Record_set_level(this_ptr: number, val: Level): void {
16127 if(!isWasmInitialized) {
16128 throw new Error("initializeWasm() must be awaited first!");
16130 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
16131 // debug statements here
16133 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
16135 export function Record_get_args(this_ptr: number): number {
16136 if(!isWasmInitialized) {
16137 throw new Error("initializeWasm() must be awaited first!");
16139 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
16140 return nativeResponseValue;
16142 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16144 export function Record_set_args(this_ptr: number, val: number): void {
16145 if(!isWasmInitialized) {
16146 throw new Error("initializeWasm() must be awaited first!");
16148 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
16149 // debug statements here
16151 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
16153 export function Record_get_module_path(this_ptr: number): number {
16154 if(!isWasmInitialized) {
16155 throw new Error("initializeWasm() must be awaited first!");
16157 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
16158 return nativeResponseValue;
16160 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16162 export function Record_set_module_path(this_ptr: number, val: number): void {
16163 if(!isWasmInitialized) {
16164 throw new Error("initializeWasm() must be awaited first!");
16166 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
16167 // debug statements here
16169 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
16171 export function Record_get_file(this_ptr: number): number {
16172 if(!isWasmInitialized) {
16173 throw new Error("initializeWasm() must be awaited first!");
16175 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
16176 return nativeResponseValue;
16178 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16180 export function Record_set_file(this_ptr: number, val: number): void {
16181 if(!isWasmInitialized) {
16182 throw new Error("initializeWasm() must be awaited first!");
16184 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
16185 // debug statements here
16187 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
16189 export function Record_get_line(this_ptr: number): number {
16190 if(!isWasmInitialized) {
16191 throw new Error("initializeWasm() must be awaited first!");
16193 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
16194 return nativeResponseValue;
16196 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
16198 export function Record_set_line(this_ptr: number, val: number): void {
16199 if(!isWasmInitialized) {
16200 throw new Error("initializeWasm() must be awaited first!");
16202 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
16203 // debug statements here
16205 // uintptr_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
16207 export function Record_clone_ptr(arg: number): number {
16208 if(!isWasmInitialized) {
16209 throw new Error("initializeWasm() must be awaited first!");
16211 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
16212 return nativeResponseValue;
16214 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
16216 export function Record_clone(orig: number): number {
16217 if(!isWasmInitialized) {
16218 throw new Error("initializeWasm() must be awaited first!");
16220 const nativeResponseValue = wasm.TS_Record_clone(orig);
16221 return nativeResponseValue;
16223 // void Logger_free(struct LDKLogger this_ptr);
16225 export function Logger_free(this_ptr: number): void {
16226 if(!isWasmInitialized) {
16227 throw new Error("initializeWasm() must be awaited first!");
16229 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
16230 // debug statements here
16232 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
16234 export function ChannelHandshakeConfig_free(this_obj: number): void {
16235 if(!isWasmInitialized) {
16236 throw new Error("initializeWasm() must be awaited first!");
16238 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
16239 // debug statements here
16241 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16243 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
16244 if(!isWasmInitialized) {
16245 throw new Error("initializeWasm() must be awaited first!");
16247 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
16248 return nativeResponseValue;
16250 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
16252 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
16253 if(!isWasmInitialized) {
16254 throw new Error("initializeWasm() must be awaited first!");
16256 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
16257 // debug statements here
16259 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16261 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
16262 if(!isWasmInitialized) {
16263 throw new Error("initializeWasm() must be awaited first!");
16265 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
16266 return nativeResponseValue;
16268 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
16270 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: number, val: number): void {
16271 if(!isWasmInitialized) {
16272 throw new Error("initializeWasm() must be awaited first!");
16274 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
16275 // debug statements here
16277 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16279 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): bigint {
16280 if(!isWasmInitialized) {
16281 throw new Error("initializeWasm() must be awaited first!");
16283 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
16284 return nativeResponseValue;
16286 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
16288 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16289 if(!isWasmInitialized) {
16290 throw new Error("initializeWasm() must be awaited first!");
16292 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
16293 // debug statements here
16295 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16297 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: number): number {
16298 if(!isWasmInitialized) {
16299 throw new Error("initializeWasm() must be awaited first!");
16301 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
16302 return nativeResponseValue;
16304 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
16306 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: number, val: number): void {
16307 if(!isWasmInitialized) {
16308 throw new Error("initializeWasm() must be awaited first!");
16310 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
16311 // debug statements here
16313 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16315 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: number): boolean {
16316 if(!isWasmInitialized) {
16317 throw new Error("initializeWasm() must be awaited first!");
16319 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
16320 return nativeResponseValue;
16322 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16324 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: number, val: boolean): void {
16325 if(!isWasmInitialized) {
16326 throw new Error("initializeWasm() must be awaited first!");
16328 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
16329 // debug statements here
16331 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16333 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: number): boolean {
16334 if(!isWasmInitialized) {
16335 throw new Error("initializeWasm() must be awaited first!");
16337 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
16338 return nativeResponseValue;
16340 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16342 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: number, val: boolean): void {
16343 if(!isWasmInitialized) {
16344 throw new Error("initializeWasm() must be awaited first!");
16346 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
16347 // debug statements here
16349 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16351 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: number): boolean {
16352 if(!isWasmInitialized) {
16353 throw new Error("initializeWasm() must be awaited first!");
16355 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
16356 return nativeResponseValue;
16358 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16360 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: number, val: boolean): void {
16361 if(!isWasmInitialized) {
16362 throw new Error("initializeWasm() must be awaited first!");
16364 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
16365 // debug statements here
16367 // 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);
16369 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 {
16370 if(!isWasmInitialized) {
16371 throw new Error("initializeWasm() must be awaited first!");
16373 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);
16374 return nativeResponseValue;
16376 // uintptr_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
16378 export function ChannelHandshakeConfig_clone_ptr(arg: number): number {
16379 if(!isWasmInitialized) {
16380 throw new Error("initializeWasm() must be awaited first!");
16382 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
16383 return nativeResponseValue;
16385 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
16387 export function ChannelHandshakeConfig_clone(orig: number): number {
16388 if(!isWasmInitialized) {
16389 throw new Error("initializeWasm() must be awaited first!");
16391 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
16392 return nativeResponseValue;
16394 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
16396 export function ChannelHandshakeConfig_default(): number {
16397 if(!isWasmInitialized) {
16398 throw new Error("initializeWasm() must be awaited first!");
16400 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
16401 return nativeResponseValue;
16403 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
16405 export function ChannelHandshakeLimits_free(this_obj: number): void {
16406 if(!isWasmInitialized) {
16407 throw new Error("initializeWasm() must be awaited first!");
16409 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
16410 // debug statements here
16412 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16414 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): bigint {
16415 if(!isWasmInitialized) {
16416 throw new Error("initializeWasm() must be awaited first!");
16418 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
16419 return nativeResponseValue;
16421 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16423 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: bigint): void {
16424 if(!isWasmInitialized) {
16425 throw new Error("initializeWasm() must be awaited first!");
16427 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
16428 // debug statements here
16430 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16432 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: number): bigint {
16433 if(!isWasmInitialized) {
16434 throw new Error("initializeWasm() must be awaited first!");
16436 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
16437 return nativeResponseValue;
16439 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16441 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: number, val: bigint): void {
16442 if(!isWasmInitialized) {
16443 throw new Error("initializeWasm() must be awaited first!");
16445 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
16446 // debug statements here
16448 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16450 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): bigint {
16451 if(!isWasmInitialized) {
16452 throw new Error("initializeWasm() must be awaited first!");
16454 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
16455 return nativeResponseValue;
16457 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16459 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16460 if(!isWasmInitialized) {
16461 throw new Error("initializeWasm() must be awaited first!");
16463 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
16464 // debug statements here
16466 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16468 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
16469 if(!isWasmInitialized) {
16470 throw new Error("initializeWasm() must be awaited first!");
16472 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
16473 return nativeResponseValue;
16475 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16477 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
16478 if(!isWasmInitialized) {
16479 throw new Error("initializeWasm() must be awaited first!");
16481 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
16482 // debug statements here
16484 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16486 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): bigint {
16487 if(!isWasmInitialized) {
16488 throw new Error("initializeWasm() must be awaited first!");
16490 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
16491 return nativeResponseValue;
16493 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16495 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
16496 if(!isWasmInitialized) {
16497 throw new Error("initializeWasm() must be awaited first!");
16499 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
16500 // debug statements here
16502 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16504 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
16505 if(!isWasmInitialized) {
16506 throw new Error("initializeWasm() must be awaited first!");
16508 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
16509 return nativeResponseValue;
16511 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
16513 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
16514 if(!isWasmInitialized) {
16515 throw new Error("initializeWasm() must be awaited first!");
16517 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
16518 // debug statements here
16520 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16522 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
16523 if(!isWasmInitialized) {
16524 throw new Error("initializeWasm() must be awaited first!");
16526 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
16527 return nativeResponseValue;
16529 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
16531 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: number, val: number): void {
16532 if(!isWasmInitialized) {
16533 throw new Error("initializeWasm() must be awaited first!");
16535 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
16536 // debug statements here
16538 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16540 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: number): boolean {
16541 if(!isWasmInitialized) {
16542 throw new Error("initializeWasm() must be awaited first!");
16544 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
16545 return nativeResponseValue;
16547 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
16549 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: number, val: boolean): void {
16550 if(!isWasmInitialized) {
16551 throw new Error("initializeWasm() must be awaited first!");
16553 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
16554 // debug statements here
16556 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16558 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
16559 if(!isWasmInitialized) {
16560 throw new Error("initializeWasm() must be awaited first!");
16562 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
16563 return nativeResponseValue;
16565 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
16567 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
16568 if(!isWasmInitialized) {
16569 throw new Error("initializeWasm() must be awaited first!");
16571 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
16572 // debug statements here
16574 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16576 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
16577 if(!isWasmInitialized) {
16578 throw new Error("initializeWasm() must be awaited first!");
16580 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
16581 return nativeResponseValue;
16583 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
16585 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
16586 if(!isWasmInitialized) {
16587 throw new Error("initializeWasm() must be awaited first!");
16589 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
16590 // debug statements here
16592 // 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);
16594 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 {
16595 if(!isWasmInitialized) {
16596 throw new Error("initializeWasm() must be awaited first!");
16598 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);
16599 return nativeResponseValue;
16601 // uintptr_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
16603 export function ChannelHandshakeLimits_clone_ptr(arg: number): number {
16604 if(!isWasmInitialized) {
16605 throw new Error("initializeWasm() must be awaited first!");
16607 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
16608 return nativeResponseValue;
16610 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
16612 export function ChannelHandshakeLimits_clone(orig: number): number {
16613 if(!isWasmInitialized) {
16614 throw new Error("initializeWasm() must be awaited first!");
16616 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
16617 return nativeResponseValue;
16619 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
16621 export function ChannelHandshakeLimits_default(): number {
16622 if(!isWasmInitialized) {
16623 throw new Error("initializeWasm() must be awaited first!");
16625 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
16626 return nativeResponseValue;
16628 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
16630 export function ChannelConfig_free(this_obj: number): void {
16631 if(!isWasmInitialized) {
16632 throw new Error("initializeWasm() must be awaited first!");
16634 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
16635 // debug statements here
16637 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16639 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: number): number {
16640 if(!isWasmInitialized) {
16641 throw new Error("initializeWasm() must be awaited first!");
16643 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
16644 return nativeResponseValue;
16646 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
16648 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: number, val: number): void {
16649 if(!isWasmInitialized) {
16650 throw new Error("initializeWasm() must be awaited first!");
16652 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
16653 // debug statements here
16655 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16657 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: number): number {
16658 if(!isWasmInitialized) {
16659 throw new Error("initializeWasm() must be awaited first!");
16661 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
16662 return nativeResponseValue;
16664 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
16666 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: number, val: number): void {
16667 if(!isWasmInitialized) {
16668 throw new Error("initializeWasm() must be awaited first!");
16670 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
16671 // debug statements here
16673 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16675 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
16676 if(!isWasmInitialized) {
16677 throw new Error("initializeWasm() must be awaited first!");
16679 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
16680 return nativeResponseValue;
16682 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
16684 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
16685 if(!isWasmInitialized) {
16686 throw new Error("initializeWasm() must be awaited first!");
16688 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
16689 // debug statements here
16691 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16693 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: number): bigint {
16694 if(!isWasmInitialized) {
16695 throw new Error("initializeWasm() must be awaited first!");
16697 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
16698 return nativeResponseValue;
16700 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
16702 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: number, val: bigint): void {
16703 if(!isWasmInitialized) {
16704 throw new Error("initializeWasm() must be awaited first!");
16706 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
16707 // debug statements here
16709 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16711 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: number): bigint {
16712 if(!isWasmInitialized) {
16713 throw new Error("initializeWasm() must be awaited first!");
16715 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
16716 return nativeResponseValue;
16718 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
16720 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: number, val: bigint): void {
16721 if(!isWasmInitialized) {
16722 throw new Error("initializeWasm() must be awaited first!");
16724 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
16725 // debug statements here
16727 // 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);
16729 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 {
16730 if(!isWasmInitialized) {
16731 throw new Error("initializeWasm() must be awaited first!");
16733 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);
16734 return nativeResponseValue;
16736 // uintptr_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
16738 export function ChannelConfig_clone_ptr(arg: number): number {
16739 if(!isWasmInitialized) {
16740 throw new Error("initializeWasm() must be awaited first!");
16742 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
16743 return nativeResponseValue;
16745 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
16747 export function ChannelConfig_clone(orig: number): number {
16748 if(!isWasmInitialized) {
16749 throw new Error("initializeWasm() must be awaited first!");
16751 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
16752 return nativeResponseValue;
16754 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
16756 export function ChannelConfig_default(): number {
16757 if(!isWasmInitialized) {
16758 throw new Error("initializeWasm() must be awaited first!");
16760 const nativeResponseValue = wasm.TS_ChannelConfig_default();
16761 return nativeResponseValue;
16763 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
16765 export function ChannelConfig_write(obj: number): number {
16766 if(!isWasmInitialized) {
16767 throw new Error("initializeWasm() must be awaited first!");
16769 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
16770 return nativeResponseValue;
16772 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
16774 export function ChannelConfig_read(ser: number): number {
16775 if(!isWasmInitialized) {
16776 throw new Error("initializeWasm() must be awaited first!");
16778 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
16779 return nativeResponseValue;
16781 // void UserConfig_free(struct LDKUserConfig this_obj);
16783 export function UserConfig_free(this_obj: number): void {
16784 if(!isWasmInitialized) {
16785 throw new Error("initializeWasm() must be awaited first!");
16787 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
16788 // debug statements here
16790 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16792 export function UserConfig_get_channel_handshake_config(this_ptr: number): number {
16793 if(!isWasmInitialized) {
16794 throw new Error("initializeWasm() must be awaited first!");
16796 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
16797 return nativeResponseValue;
16799 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
16801 export function UserConfig_set_channel_handshake_config(this_ptr: number, val: number): void {
16802 if(!isWasmInitialized) {
16803 throw new Error("initializeWasm() must be awaited first!");
16805 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
16806 // debug statements here
16808 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16810 export function UserConfig_get_channel_handshake_limits(this_ptr: number): number {
16811 if(!isWasmInitialized) {
16812 throw new Error("initializeWasm() must be awaited first!");
16814 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
16815 return nativeResponseValue;
16817 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
16819 export function UserConfig_set_channel_handshake_limits(this_ptr: number, val: number): void {
16820 if(!isWasmInitialized) {
16821 throw new Error("initializeWasm() must be awaited first!");
16823 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
16824 // debug statements here
16826 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16828 export function UserConfig_get_channel_config(this_ptr: number): number {
16829 if(!isWasmInitialized) {
16830 throw new Error("initializeWasm() must be awaited first!");
16832 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
16833 return nativeResponseValue;
16835 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
16837 export function UserConfig_set_channel_config(this_ptr: number, val: number): void {
16838 if(!isWasmInitialized) {
16839 throw new Error("initializeWasm() must be awaited first!");
16841 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
16842 // debug statements here
16844 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16846 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: number): boolean {
16847 if(!isWasmInitialized) {
16848 throw new Error("initializeWasm() must be awaited first!");
16850 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
16851 return nativeResponseValue;
16853 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16855 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: number, val: boolean): void {
16856 if(!isWasmInitialized) {
16857 throw new Error("initializeWasm() must be awaited first!");
16859 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
16860 // debug statements here
16862 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16864 export function UserConfig_get_accept_inbound_channels(this_ptr: number): boolean {
16865 if(!isWasmInitialized) {
16866 throw new Error("initializeWasm() must be awaited first!");
16868 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
16869 return nativeResponseValue;
16871 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16873 export function UserConfig_set_accept_inbound_channels(this_ptr: number, val: boolean): void {
16874 if(!isWasmInitialized) {
16875 throw new Error("initializeWasm() must be awaited first!");
16877 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
16878 // debug statements here
16880 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16882 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: number): boolean {
16883 if(!isWasmInitialized) {
16884 throw new Error("initializeWasm() must be awaited first!");
16886 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
16887 return nativeResponseValue;
16889 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16891 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: number, val: boolean): void {
16892 if(!isWasmInitialized) {
16893 throw new Error("initializeWasm() must be awaited first!");
16895 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
16896 // debug statements here
16898 // 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);
16900 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 {
16901 if(!isWasmInitialized) {
16902 throw new Error("initializeWasm() must be awaited first!");
16904 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);
16905 return nativeResponseValue;
16907 // uintptr_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
16909 export function UserConfig_clone_ptr(arg: number): number {
16910 if(!isWasmInitialized) {
16911 throw new Error("initializeWasm() must be awaited first!");
16913 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
16914 return nativeResponseValue;
16916 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
16918 export function UserConfig_clone(orig: number): number {
16919 if(!isWasmInitialized) {
16920 throw new Error("initializeWasm() must be awaited first!");
16922 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
16923 return nativeResponseValue;
16925 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
16927 export function UserConfig_default(): number {
16928 if(!isWasmInitialized) {
16929 throw new Error("initializeWasm() must be awaited first!");
16931 const nativeResponseValue = wasm.TS_UserConfig_default();
16932 return nativeResponseValue;
16934 // void BestBlock_free(struct LDKBestBlock this_obj);
16936 export function BestBlock_free(this_obj: number): void {
16937 if(!isWasmInitialized) {
16938 throw new Error("initializeWasm() must be awaited first!");
16940 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
16941 // debug statements here
16943 // uintptr_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
16945 export function BestBlock_clone_ptr(arg: number): number {
16946 if(!isWasmInitialized) {
16947 throw new Error("initializeWasm() must be awaited first!");
16949 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
16950 return nativeResponseValue;
16952 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
16954 export function BestBlock_clone(orig: number): number {
16955 if(!isWasmInitialized) {
16956 throw new Error("initializeWasm() must be awaited first!");
16958 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
16959 return nativeResponseValue;
16961 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
16963 export function BestBlock_from_genesis(network: Network): number {
16964 if(!isWasmInitialized) {
16965 throw new Error("initializeWasm() must be awaited first!");
16967 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
16968 return nativeResponseValue;
16970 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
16972 export function BestBlock_new(block_hash: number, height: number): number {
16973 if(!isWasmInitialized) {
16974 throw new Error("initializeWasm() must be awaited first!");
16976 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
16977 return nativeResponseValue;
16979 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
16981 export function BestBlock_block_hash(this_arg: number): number {
16982 if(!isWasmInitialized) {
16983 throw new Error("initializeWasm() must be awaited first!");
16985 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
16986 return nativeResponseValue;
16988 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
16990 export function BestBlock_height(this_arg: number): number {
16991 if(!isWasmInitialized) {
16992 throw new Error("initializeWasm() must be awaited first!");
16994 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
16995 return nativeResponseValue;
16997 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
16999 export function AccessError_clone(orig: number): AccessError {
17000 if(!isWasmInitialized) {
17001 throw new Error("initializeWasm() must be awaited first!");
17003 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
17004 return nativeResponseValue;
17006 // enum LDKAccessError AccessError_unknown_chain(void);
17008 export function AccessError_unknown_chain(): AccessError {
17009 if(!isWasmInitialized) {
17010 throw new Error("initializeWasm() must be awaited first!");
17012 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
17013 return nativeResponseValue;
17015 // enum LDKAccessError AccessError_unknown_tx(void);
17017 export function AccessError_unknown_tx(): AccessError {
17018 if(!isWasmInitialized) {
17019 throw new Error("initializeWasm() must be awaited first!");
17021 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
17022 return nativeResponseValue;
17024 // void Access_free(struct LDKAccess this_ptr);
17026 export function Access_free(this_ptr: number): void {
17027 if(!isWasmInitialized) {
17028 throw new Error("initializeWasm() must be awaited first!");
17030 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
17031 // debug statements here
17033 // void Listen_free(struct LDKListen this_ptr);
17035 export function Listen_free(this_ptr: number): void {
17036 if(!isWasmInitialized) {
17037 throw new Error("initializeWasm() must be awaited first!");
17039 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
17040 // debug statements here
17042 // void Confirm_free(struct LDKConfirm this_ptr);
17044 export function Confirm_free(this_ptr: number): void {
17045 if(!isWasmInitialized) {
17046 throw new Error("initializeWasm() must be awaited first!");
17048 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
17049 // debug statements here
17051 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
17053 export function ChannelMonitorUpdateErr_clone(orig: number): ChannelMonitorUpdateErr {
17054 if(!isWasmInitialized) {
17055 throw new Error("initializeWasm() must be awaited first!");
17057 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
17058 return nativeResponseValue;
17060 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
17062 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
17063 if(!isWasmInitialized) {
17064 throw new Error("initializeWasm() must be awaited first!");
17066 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
17067 return nativeResponseValue;
17069 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
17071 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
17072 if(!isWasmInitialized) {
17073 throw new Error("initializeWasm() must be awaited first!");
17075 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
17076 return nativeResponseValue;
17078 // void Watch_free(struct LDKWatch this_ptr);
17080 export function Watch_free(this_ptr: number): void {
17081 if(!isWasmInitialized) {
17082 throw new Error("initializeWasm() must be awaited first!");
17084 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
17085 // debug statements here
17087 // void Filter_free(struct LDKFilter this_ptr);
17089 export function Filter_free(this_ptr: number): void {
17090 if(!isWasmInitialized) {
17091 throw new Error("initializeWasm() must be awaited first!");
17093 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
17094 // debug statements here
17096 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
17098 export function WatchedOutput_free(this_obj: number): void {
17099 if(!isWasmInitialized) {
17100 throw new Error("initializeWasm() must be awaited first!");
17102 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
17103 // debug statements here
17105 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17107 export function WatchedOutput_get_block_hash(this_ptr: number): number {
17108 if(!isWasmInitialized) {
17109 throw new Error("initializeWasm() must be awaited first!");
17111 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
17112 return nativeResponseValue;
17114 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17116 export function WatchedOutput_set_block_hash(this_ptr: number, val: number): void {
17117 if(!isWasmInitialized) {
17118 throw new Error("initializeWasm() must be awaited first!");
17120 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
17121 // debug statements here
17123 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17125 export function WatchedOutput_get_outpoint(this_ptr: number): number {
17126 if(!isWasmInitialized) {
17127 throw new Error("initializeWasm() must be awaited first!");
17129 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
17130 return nativeResponseValue;
17132 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17134 export function WatchedOutput_set_outpoint(this_ptr: number, val: number): void {
17135 if(!isWasmInitialized) {
17136 throw new Error("initializeWasm() must be awaited first!");
17138 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
17139 // debug statements here
17141 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17143 export function WatchedOutput_get_script_pubkey(this_ptr: number): number {
17144 if(!isWasmInitialized) {
17145 throw new Error("initializeWasm() must be awaited first!");
17147 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
17148 return nativeResponseValue;
17150 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
17152 export function WatchedOutput_set_script_pubkey(this_ptr: number, val: number): void {
17153 if(!isWasmInitialized) {
17154 throw new Error("initializeWasm() must be awaited first!");
17156 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
17157 // debug statements here
17159 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
17161 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: number, script_pubkey_arg: number): number {
17162 if(!isWasmInitialized) {
17163 throw new Error("initializeWasm() must be awaited first!");
17165 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
17166 return nativeResponseValue;
17168 // uintptr_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
17170 export function WatchedOutput_clone_ptr(arg: number): number {
17171 if(!isWasmInitialized) {
17172 throw new Error("initializeWasm() must be awaited first!");
17174 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
17175 return nativeResponseValue;
17177 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
17179 export function WatchedOutput_clone(orig: number): number {
17180 if(!isWasmInitialized) {
17181 throw new Error("initializeWasm() must be awaited first!");
17183 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
17184 return nativeResponseValue;
17186 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
17188 export function WatchedOutput_hash(o: number): bigint {
17189 if(!isWasmInitialized) {
17190 throw new Error("initializeWasm() must be awaited first!");
17192 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
17193 return nativeResponseValue;
17195 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
17197 export function BroadcasterInterface_free(this_ptr: number): void {
17198 if(!isWasmInitialized) {
17199 throw new Error("initializeWasm() must be awaited first!");
17201 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
17202 // debug statements here
17204 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
17206 export function ConfirmationTarget_clone(orig: number): ConfirmationTarget {
17207 if(!isWasmInitialized) {
17208 throw new Error("initializeWasm() must be awaited first!");
17210 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
17211 return nativeResponseValue;
17213 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
17215 export function ConfirmationTarget_background(): ConfirmationTarget {
17216 if(!isWasmInitialized) {
17217 throw new Error("initializeWasm() must be awaited first!");
17219 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
17220 return nativeResponseValue;
17222 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
17224 export function ConfirmationTarget_normal(): ConfirmationTarget {
17225 if(!isWasmInitialized) {
17226 throw new Error("initializeWasm() must be awaited first!");
17228 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
17229 return nativeResponseValue;
17231 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
17233 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
17234 if(!isWasmInitialized) {
17235 throw new Error("initializeWasm() must be awaited first!");
17237 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
17238 return nativeResponseValue;
17240 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
17242 export function ConfirmationTarget_eq(a: number, b: number): boolean {
17243 if(!isWasmInitialized) {
17244 throw new Error("initializeWasm() must be awaited first!");
17246 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
17247 return nativeResponseValue;
17249 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
17251 export function FeeEstimator_free(this_ptr: number): void {
17252 if(!isWasmInitialized) {
17253 throw new Error("initializeWasm() must be awaited first!");
17255 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
17256 // debug statements here
17258 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
17260 export function MonitorUpdateId_free(this_obj: number): void {
17261 if(!isWasmInitialized) {
17262 throw new Error("initializeWasm() must be awaited first!");
17264 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
17265 // debug statements here
17267 // uintptr_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
17269 export function MonitorUpdateId_clone_ptr(arg: number): number {
17270 if(!isWasmInitialized) {
17271 throw new Error("initializeWasm() must be awaited first!");
17273 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
17274 return nativeResponseValue;
17276 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
17278 export function MonitorUpdateId_clone(orig: number): number {
17279 if(!isWasmInitialized) {
17280 throw new Error("initializeWasm() must be awaited first!");
17282 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
17283 return nativeResponseValue;
17285 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
17287 export function MonitorUpdateId_hash(o: number): bigint {
17288 if(!isWasmInitialized) {
17289 throw new Error("initializeWasm() must be awaited first!");
17291 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
17292 return nativeResponseValue;
17294 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
17296 export function MonitorUpdateId_eq(a: number, b: number): boolean {
17297 if(!isWasmInitialized) {
17298 throw new Error("initializeWasm() must be awaited first!");
17300 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
17301 return nativeResponseValue;
17303 // void Persist_free(struct LDKPersist this_ptr);
17305 export function Persist_free(this_ptr: number): void {
17306 if(!isWasmInitialized) {
17307 throw new Error("initializeWasm() must be awaited first!");
17309 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
17310 // debug statements here
17312 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
17314 export function LockedChannelMonitor_free(this_obj: number): void {
17315 if(!isWasmInitialized) {
17316 throw new Error("initializeWasm() must be awaited first!");
17318 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
17319 // debug statements here
17321 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
17323 export function ChainMonitor_free(this_obj: number): void {
17324 if(!isWasmInitialized) {
17325 throw new Error("initializeWasm() must be awaited first!");
17327 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
17328 // debug statements here
17330 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
17332 export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
17333 if(!isWasmInitialized) {
17334 throw new Error("initializeWasm() must be awaited first!");
17336 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
17337 return nativeResponseValue;
17339 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
17341 export function ChainMonitor_get_claimable_balances(this_arg: number, ignored_channels: number): number {
17342 if(!isWasmInitialized) {
17343 throw new Error("initializeWasm() must be awaited first!");
17345 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
17346 return nativeResponseValue;
17348 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
17350 export function ChainMonitor_get_monitor(this_arg: number, funding_txo: number): number {
17351 if(!isWasmInitialized) {
17352 throw new Error("initializeWasm() must be awaited first!");
17354 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
17355 return nativeResponseValue;
17357 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17359 export function ChainMonitor_list_monitors(this_arg: number): number {
17360 if(!isWasmInitialized) {
17361 throw new Error("initializeWasm() must be awaited first!");
17363 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
17364 return nativeResponseValue;
17366 // 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);
17368 export function ChainMonitor_channel_monitor_updated(this_arg: number, funding_txo: number, completed_update_id: number): number {
17369 if(!isWasmInitialized) {
17370 throw new Error("initializeWasm() must be awaited first!");
17372 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
17373 return nativeResponseValue;
17375 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17377 export function ChainMonitor_as_Listen(this_arg: number): number {
17378 if(!isWasmInitialized) {
17379 throw new Error("initializeWasm() must be awaited first!");
17381 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
17382 return nativeResponseValue;
17384 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17386 export function ChainMonitor_as_Confirm(this_arg: number): number {
17387 if(!isWasmInitialized) {
17388 throw new Error("initializeWasm() must be awaited first!");
17390 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
17391 return nativeResponseValue;
17393 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17395 export function ChainMonitor_as_Watch(this_arg: number): number {
17396 if(!isWasmInitialized) {
17397 throw new Error("initializeWasm() must be awaited first!");
17399 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
17400 return nativeResponseValue;
17402 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17404 export function ChainMonitor_as_EventsProvider(this_arg: number): number {
17405 if(!isWasmInitialized) {
17406 throw new Error("initializeWasm() must be awaited first!");
17408 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
17409 return nativeResponseValue;
17411 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
17413 export function ChannelMonitorUpdate_free(this_obj: number): void {
17414 if(!isWasmInitialized) {
17415 throw new Error("initializeWasm() must be awaited first!");
17417 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
17418 // debug statements here
17420 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
17422 export function ChannelMonitorUpdate_get_update_id(this_ptr: number): bigint {
17423 if(!isWasmInitialized) {
17424 throw new Error("initializeWasm() must be awaited first!");
17426 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
17427 return nativeResponseValue;
17429 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
17431 export function ChannelMonitorUpdate_set_update_id(this_ptr: number, val: bigint): void {
17432 if(!isWasmInitialized) {
17433 throw new Error("initializeWasm() must be awaited first!");
17435 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
17436 // debug statements here
17438 // uintptr_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
17440 export function ChannelMonitorUpdate_clone_ptr(arg: number): number {
17441 if(!isWasmInitialized) {
17442 throw new Error("initializeWasm() must be awaited first!");
17444 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
17445 return nativeResponseValue;
17447 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
17449 export function ChannelMonitorUpdate_clone(orig: number): number {
17450 if(!isWasmInitialized) {
17451 throw new Error("initializeWasm() must be awaited first!");
17453 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
17454 return nativeResponseValue;
17456 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
17458 export function ChannelMonitorUpdate_write(obj: number): number {
17459 if(!isWasmInitialized) {
17460 throw new Error("initializeWasm() must be awaited first!");
17462 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
17463 return nativeResponseValue;
17465 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
17467 export function ChannelMonitorUpdate_read(ser: number): number {
17468 if(!isWasmInitialized) {
17469 throw new Error("initializeWasm() must be awaited first!");
17471 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
17472 return nativeResponseValue;
17474 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
17476 export function MonitorEvent_free(this_ptr: number): void {
17477 if(!isWasmInitialized) {
17478 throw new Error("initializeWasm() must be awaited first!");
17480 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
17481 // debug statements here
17483 // uintptr_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
17485 export function MonitorEvent_clone_ptr(arg: number): number {
17486 if(!isWasmInitialized) {
17487 throw new Error("initializeWasm() must be awaited first!");
17489 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
17490 return nativeResponseValue;
17492 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
17494 export function MonitorEvent_clone(orig: number): number {
17495 if(!isWasmInitialized) {
17496 throw new Error("initializeWasm() must be awaited first!");
17498 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
17499 return nativeResponseValue;
17501 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
17503 export function MonitorEvent_htlcevent(a: number): number {
17504 if(!isWasmInitialized) {
17505 throw new Error("initializeWasm() must be awaited first!");
17507 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
17508 return nativeResponseValue;
17510 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
17512 export function MonitorEvent_commitment_tx_confirmed(a: number): number {
17513 if(!isWasmInitialized) {
17514 throw new Error("initializeWasm() must be awaited first!");
17516 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
17517 return nativeResponseValue;
17519 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
17521 export function MonitorEvent_update_completed(funding_txo: number, monitor_update_id: bigint): number {
17522 if(!isWasmInitialized) {
17523 throw new Error("initializeWasm() must be awaited first!");
17525 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
17526 return nativeResponseValue;
17528 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
17530 export function MonitorEvent_update_failed(a: number): number {
17531 if(!isWasmInitialized) {
17532 throw new Error("initializeWasm() must be awaited first!");
17534 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
17535 return nativeResponseValue;
17537 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
17539 export function MonitorEvent_write(obj: number): number {
17540 if(!isWasmInitialized) {
17541 throw new Error("initializeWasm() must be awaited first!");
17543 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
17544 return nativeResponseValue;
17546 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
17548 export function MonitorEvent_read(ser: number): number {
17549 if(!isWasmInitialized) {
17550 throw new Error("initializeWasm() must be awaited first!");
17552 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
17553 return nativeResponseValue;
17555 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
17557 export function HTLCUpdate_free(this_obj: number): void {
17558 if(!isWasmInitialized) {
17559 throw new Error("initializeWasm() must be awaited first!");
17561 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
17562 // debug statements here
17564 // uintptr_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
17566 export function HTLCUpdate_clone_ptr(arg: number): number {
17567 if(!isWasmInitialized) {
17568 throw new Error("initializeWasm() must be awaited first!");
17570 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
17571 return nativeResponseValue;
17573 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
17575 export function HTLCUpdate_clone(orig: number): number {
17576 if(!isWasmInitialized) {
17577 throw new Error("initializeWasm() must be awaited first!");
17579 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
17580 return nativeResponseValue;
17582 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
17584 export function HTLCUpdate_write(obj: number): number {
17585 if(!isWasmInitialized) {
17586 throw new Error("initializeWasm() must be awaited first!");
17588 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
17589 return nativeResponseValue;
17591 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
17593 export function HTLCUpdate_read(ser: number): number {
17594 if(!isWasmInitialized) {
17595 throw new Error("initializeWasm() must be awaited first!");
17597 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
17598 return nativeResponseValue;
17600 // void Balance_free(struct LDKBalance this_ptr);
17602 export function Balance_free(this_ptr: number): void {
17603 if(!isWasmInitialized) {
17604 throw new Error("initializeWasm() must be awaited first!");
17606 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
17607 // debug statements here
17609 // uintptr_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
17611 export function Balance_clone_ptr(arg: number): number {
17612 if(!isWasmInitialized) {
17613 throw new Error("initializeWasm() must be awaited first!");
17615 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
17616 return nativeResponseValue;
17618 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
17620 export function Balance_clone(orig: number): number {
17621 if(!isWasmInitialized) {
17622 throw new Error("initializeWasm() must be awaited first!");
17624 const nativeResponseValue = wasm.TS_Balance_clone(orig);
17625 return nativeResponseValue;
17627 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
17629 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): number {
17630 if(!isWasmInitialized) {
17631 throw new Error("initializeWasm() must be awaited first!");
17633 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
17634 return nativeResponseValue;
17636 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
17638 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): number {
17639 if(!isWasmInitialized) {
17640 throw new Error("initializeWasm() must be awaited first!");
17642 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
17643 return nativeResponseValue;
17645 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
17647 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): number {
17648 if(!isWasmInitialized) {
17649 throw new Error("initializeWasm() must be awaited first!");
17651 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
17652 return nativeResponseValue;
17654 // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
17656 export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: bigint, claimable_height: number): number {
17657 if(!isWasmInitialized) {
17658 throw new Error("initializeWasm() must be awaited first!");
17660 const nativeResponseValue = wasm.TS_Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
17661 return nativeResponseValue;
17663 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
17665 export function Balance_eq(a: number, b: number): boolean {
17666 if(!isWasmInitialized) {
17667 throw new Error("initializeWasm() must be awaited first!");
17669 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
17670 return nativeResponseValue;
17672 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
17674 export function ChannelMonitor_free(this_obj: number): void {
17675 if(!isWasmInitialized) {
17676 throw new Error("initializeWasm() must be awaited first!");
17678 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
17679 // debug statements here
17681 // uintptr_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
17683 export function ChannelMonitor_clone_ptr(arg: number): number {
17684 if(!isWasmInitialized) {
17685 throw new Error("initializeWasm() must be awaited first!");
17687 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
17688 return nativeResponseValue;
17690 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
17692 export function ChannelMonitor_clone(orig: number): number {
17693 if(!isWasmInitialized) {
17694 throw new Error("initializeWasm() must be awaited first!");
17696 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
17697 return nativeResponseValue;
17699 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
17701 export function ChannelMonitor_write(obj: number): number {
17702 if(!isWasmInitialized) {
17703 throw new Error("initializeWasm() must be awaited first!");
17705 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
17706 return nativeResponseValue;
17708 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
17710 export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
17711 if(!isWasmInitialized) {
17712 throw new Error("initializeWasm() must be awaited first!");
17714 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
17715 return nativeResponseValue;
17717 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17719 export function ChannelMonitor_get_latest_update_id(this_arg: number): bigint {
17720 if(!isWasmInitialized) {
17721 throw new Error("initializeWasm() must be awaited first!");
17723 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
17724 return nativeResponseValue;
17726 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17728 export function ChannelMonitor_get_funding_txo(this_arg: number): number {
17729 if(!isWasmInitialized) {
17730 throw new Error("initializeWasm() must be awaited first!");
17732 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
17733 return nativeResponseValue;
17735 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17737 export function ChannelMonitor_get_outputs_to_watch(this_arg: number): number {
17738 if(!isWasmInitialized) {
17739 throw new Error("initializeWasm() must be awaited first!");
17741 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
17742 return nativeResponseValue;
17744 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
17746 export function ChannelMonitor_load_outputs_to_watch(this_arg: number, filter: number): void {
17747 if(!isWasmInitialized) {
17748 throw new Error("initializeWasm() must be awaited first!");
17750 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
17751 // debug statements here
17753 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17755 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number {
17756 if(!isWasmInitialized) {
17757 throw new Error("initializeWasm() must be awaited first!");
17759 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
17760 return nativeResponseValue;
17762 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17764 export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number {
17765 if(!isWasmInitialized) {
17766 throw new Error("initializeWasm() must be awaited first!");
17768 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
17769 return nativeResponseValue;
17771 // 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);
17773 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): number {
17774 if(!isWasmInitialized) {
17775 throw new Error("initializeWasm() must be awaited first!");
17777 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
17778 return nativeResponseValue;
17780 // 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);
17782 export function ChannelMonitor_block_connected(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17783 if(!isWasmInitialized) {
17784 throw new Error("initializeWasm() must be awaited first!");
17786 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
17787 return nativeResponseValue;
17789 // 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);
17791 export function ChannelMonitor_block_disconnected(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
17792 if(!isWasmInitialized) {
17793 throw new Error("initializeWasm() must be awaited first!");
17795 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
17796 // debug statements here
17798 // 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);
17800 export function ChannelMonitor_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17801 if(!isWasmInitialized) {
17802 throw new Error("initializeWasm() must be awaited first!");
17804 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
17805 return nativeResponseValue;
17807 // 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);
17809 export function ChannelMonitor_transaction_unconfirmed(this_arg: number, txid: number, broadcaster: number, fee_estimator: number, logger: number): void {
17810 if(!isWasmInitialized) {
17811 throw new Error("initializeWasm() must be awaited first!");
17813 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
17814 // debug statements here
17816 // 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);
17818 export function ChannelMonitor_best_block_updated(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17819 if(!isWasmInitialized) {
17820 throw new Error("initializeWasm() must be awaited first!");
17822 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
17823 return nativeResponseValue;
17825 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17827 export function ChannelMonitor_get_relevant_txids(this_arg: number): number {
17828 if(!isWasmInitialized) {
17829 throw new Error("initializeWasm() must be awaited first!");
17831 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
17832 return nativeResponseValue;
17834 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17836 export function ChannelMonitor_current_best_block(this_arg: number): number {
17837 if(!isWasmInitialized) {
17838 throw new Error("initializeWasm() must be awaited first!");
17840 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
17841 return nativeResponseValue;
17843 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17845 export function ChannelMonitor_get_claimable_balances(this_arg: number): number {
17846 if(!isWasmInitialized) {
17847 throw new Error("initializeWasm() must be awaited first!");
17849 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
17850 return nativeResponseValue;
17852 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
17854 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: number): number {
17855 if(!isWasmInitialized) {
17856 throw new Error("initializeWasm() must be awaited first!");
17858 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
17859 return nativeResponseValue;
17861 // void OutPoint_free(struct LDKOutPoint this_obj);
17863 export function OutPoint_free(this_obj: number): void {
17864 if(!isWasmInitialized) {
17865 throw new Error("initializeWasm() must be awaited first!");
17867 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
17868 // debug statements here
17870 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
17872 export function OutPoint_get_txid(this_ptr: number): number {
17873 if(!isWasmInitialized) {
17874 throw new Error("initializeWasm() must be awaited first!");
17876 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
17877 return nativeResponseValue;
17879 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17881 export function OutPoint_set_txid(this_ptr: number, val: number): void {
17882 if(!isWasmInitialized) {
17883 throw new Error("initializeWasm() must be awaited first!");
17885 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
17886 // debug statements here
17888 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
17890 export function OutPoint_get_index(this_ptr: number): number {
17891 if(!isWasmInitialized) {
17892 throw new Error("initializeWasm() must be awaited first!");
17894 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
17895 return nativeResponseValue;
17897 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
17899 export function OutPoint_set_index(this_ptr: number, val: number): void {
17900 if(!isWasmInitialized) {
17901 throw new Error("initializeWasm() must be awaited first!");
17903 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
17904 // debug statements here
17906 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
17908 export function OutPoint_new(txid_arg: number, index_arg: number): number {
17909 if(!isWasmInitialized) {
17910 throw new Error("initializeWasm() must be awaited first!");
17912 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
17913 return nativeResponseValue;
17915 // uintptr_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
17917 export function OutPoint_clone_ptr(arg: number): number {
17918 if(!isWasmInitialized) {
17919 throw new Error("initializeWasm() must be awaited first!");
17921 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
17922 return nativeResponseValue;
17924 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
17926 export function OutPoint_clone(orig: number): number {
17927 if(!isWasmInitialized) {
17928 throw new Error("initializeWasm() must be awaited first!");
17930 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
17931 return nativeResponseValue;
17933 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
17935 export function OutPoint_eq(a: number, b: number): boolean {
17936 if(!isWasmInitialized) {
17937 throw new Error("initializeWasm() must be awaited first!");
17939 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
17940 return nativeResponseValue;
17942 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
17944 export function OutPoint_hash(o: number): bigint {
17945 if(!isWasmInitialized) {
17946 throw new Error("initializeWasm() must be awaited first!");
17948 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
17949 return nativeResponseValue;
17951 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
17953 export function OutPoint_to_channel_id(this_arg: number): number {
17954 if(!isWasmInitialized) {
17955 throw new Error("initializeWasm() must be awaited first!");
17957 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
17958 return nativeResponseValue;
17960 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
17962 export function OutPoint_write(obj: number): number {
17963 if(!isWasmInitialized) {
17964 throw new Error("initializeWasm() must be awaited first!");
17966 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
17967 return nativeResponseValue;
17969 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
17971 export function OutPoint_read(ser: number): number {
17972 if(!isWasmInitialized) {
17973 throw new Error("initializeWasm() must be awaited first!");
17975 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
17976 return nativeResponseValue;
17978 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
17980 export function DelayedPaymentOutputDescriptor_free(this_obj: number): void {
17981 if(!isWasmInitialized) {
17982 throw new Error("initializeWasm() must be awaited first!");
17984 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
17985 // debug statements here
17987 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17989 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
17990 if(!isWasmInitialized) {
17991 throw new Error("initializeWasm() must be awaited first!");
17993 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
17994 return nativeResponseValue;
17996 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17998 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
17999 if(!isWasmInitialized) {
18000 throw new Error("initializeWasm() must be awaited first!");
18002 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
18003 // debug statements here
18005 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18007 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): number {
18008 if(!isWasmInitialized) {
18009 throw new Error("initializeWasm() must be awaited first!");
18011 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
18012 return nativeResponseValue;
18014 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18016 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: number, val: number): void {
18017 if(!isWasmInitialized) {
18018 throw new Error("initializeWasm() must be awaited first!");
18020 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
18021 // debug statements here
18023 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18025 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number {
18026 if(!isWasmInitialized) {
18027 throw new Error("initializeWasm() must be awaited first!");
18029 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
18030 return nativeResponseValue;
18032 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
18034 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: number, val: number): void {
18035 if(!isWasmInitialized) {
18036 throw new Error("initializeWasm() must be awaited first!");
18038 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
18039 // debug statements here
18041 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
18043 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
18044 if(!isWasmInitialized) {
18045 throw new Error("initializeWasm() must be awaited first!");
18047 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
18048 // debug statements here
18050 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18052 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): number {
18053 if(!isWasmInitialized) {
18054 throw new Error("initializeWasm() must be awaited first!");
18056 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
18057 return nativeResponseValue;
18059 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18061 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: number, val: number): void {
18062 if(!isWasmInitialized) {
18063 throw new Error("initializeWasm() must be awaited first!");
18065 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
18066 // debug statements here
18068 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
18070 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
18071 if(!isWasmInitialized) {
18072 throw new Error("initializeWasm() must be awaited first!");
18074 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
18075 return nativeResponseValue;
18077 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18079 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
18080 if(!isWasmInitialized) {
18081 throw new Error("initializeWasm() must be awaited first!");
18083 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
18084 // debug statements here
18086 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18088 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
18089 if(!isWasmInitialized) {
18090 throw new Error("initializeWasm() must be awaited first!");
18092 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
18093 return nativeResponseValue;
18095 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
18097 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18098 if(!isWasmInitialized) {
18099 throw new Error("initializeWasm() must be awaited first!");
18101 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
18102 // debug statements here
18104 // 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);
18106 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 {
18107 if(!isWasmInitialized) {
18108 throw new Error("initializeWasm() must be awaited first!");
18110 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);
18111 return nativeResponseValue;
18113 // uintptr_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
18115 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: number): number {
18116 if(!isWasmInitialized) {
18117 throw new Error("initializeWasm() must be awaited first!");
18119 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
18120 return nativeResponseValue;
18122 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
18124 export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
18125 if(!isWasmInitialized) {
18126 throw new Error("initializeWasm() must be awaited first!");
18128 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
18129 return nativeResponseValue;
18131 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
18133 export function DelayedPaymentOutputDescriptor_write(obj: number): number {
18134 if(!isWasmInitialized) {
18135 throw new Error("initializeWasm() must be awaited first!");
18137 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
18138 return nativeResponseValue;
18140 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
18142 export function DelayedPaymentOutputDescriptor_read(ser: number): number {
18143 if(!isWasmInitialized) {
18144 throw new Error("initializeWasm() must be awaited first!");
18146 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
18147 return nativeResponseValue;
18149 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
18151 export function StaticPaymentOutputDescriptor_free(this_obj: number): void {
18152 if(!isWasmInitialized) {
18153 throw new Error("initializeWasm() must be awaited first!");
18155 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
18156 // debug statements here
18158 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18160 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
18161 if(!isWasmInitialized) {
18162 throw new Error("initializeWasm() must be awaited first!");
18164 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
18165 return nativeResponseValue;
18167 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18169 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
18170 if(!isWasmInitialized) {
18171 throw new Error("initializeWasm() must be awaited first!");
18173 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
18174 // debug statements here
18176 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
18178 export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
18179 if(!isWasmInitialized) {
18180 throw new Error("initializeWasm() must be awaited first!");
18182 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
18183 // debug statements here
18185 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
18187 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
18188 if(!isWasmInitialized) {
18189 throw new Error("initializeWasm() must be awaited first!");
18191 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
18192 return nativeResponseValue;
18194 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18196 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
18197 if(!isWasmInitialized) {
18198 throw new Error("initializeWasm() must be awaited first!");
18200 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
18201 // debug statements here
18203 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18205 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
18206 if(!isWasmInitialized) {
18207 throw new Error("initializeWasm() must be awaited first!");
18209 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
18210 return nativeResponseValue;
18212 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
18214 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18215 if(!isWasmInitialized) {
18216 throw new Error("initializeWasm() must be awaited first!");
18218 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
18219 // debug statements here
18221 // 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);
18223 export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
18224 if(!isWasmInitialized) {
18225 throw new Error("initializeWasm() must be awaited first!");
18227 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
18228 return nativeResponseValue;
18230 // uintptr_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
18232 export function StaticPaymentOutputDescriptor_clone_ptr(arg: number): number {
18233 if(!isWasmInitialized) {
18234 throw new Error("initializeWasm() must be awaited first!");
18236 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
18237 return nativeResponseValue;
18239 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
18241 export function StaticPaymentOutputDescriptor_clone(orig: number): number {
18242 if(!isWasmInitialized) {
18243 throw new Error("initializeWasm() must be awaited first!");
18245 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
18246 return nativeResponseValue;
18248 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
18250 export function StaticPaymentOutputDescriptor_write(obj: number): number {
18251 if(!isWasmInitialized) {
18252 throw new Error("initializeWasm() must be awaited first!");
18254 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
18255 return nativeResponseValue;
18257 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
18259 export function StaticPaymentOutputDescriptor_read(ser: number): number {
18260 if(!isWasmInitialized) {
18261 throw new Error("initializeWasm() must be awaited first!");
18263 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
18264 return nativeResponseValue;
18266 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
18268 export function SpendableOutputDescriptor_free(this_ptr: number): void {
18269 if(!isWasmInitialized) {
18270 throw new Error("initializeWasm() must be awaited first!");
18272 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
18273 // debug statements here
18275 // uintptr_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
18277 export function SpendableOutputDescriptor_clone_ptr(arg: number): number {
18278 if(!isWasmInitialized) {
18279 throw new Error("initializeWasm() must be awaited first!");
18281 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
18282 return nativeResponseValue;
18284 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
18286 export function SpendableOutputDescriptor_clone(orig: number): number {
18287 if(!isWasmInitialized) {
18288 throw new Error("initializeWasm() must be awaited first!");
18290 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
18291 return nativeResponseValue;
18293 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
18295 export function SpendableOutputDescriptor_static_output(outpoint: number, output: number): number {
18296 if(!isWasmInitialized) {
18297 throw new Error("initializeWasm() must be awaited first!");
18299 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
18300 return nativeResponseValue;
18302 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
18304 export function SpendableOutputDescriptor_delayed_payment_output(a: number): number {
18305 if(!isWasmInitialized) {
18306 throw new Error("initializeWasm() must be awaited first!");
18308 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
18309 return nativeResponseValue;
18311 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
18313 export function SpendableOutputDescriptor_static_payment_output(a: number): number {
18314 if(!isWasmInitialized) {
18315 throw new Error("initializeWasm() must be awaited first!");
18317 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
18318 return nativeResponseValue;
18320 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
18322 export function SpendableOutputDescriptor_write(obj: number): number {
18323 if(!isWasmInitialized) {
18324 throw new Error("initializeWasm() must be awaited first!");
18326 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
18327 return nativeResponseValue;
18329 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
18331 export function SpendableOutputDescriptor_read(ser: number): number {
18332 if(!isWasmInitialized) {
18333 throw new Error("initializeWasm() must be awaited first!");
18335 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
18336 return nativeResponseValue;
18338 // void BaseSign_free(struct LDKBaseSign this_ptr);
18340 export function BaseSign_free(this_ptr: number): void {
18341 if(!isWasmInitialized) {
18342 throw new Error("initializeWasm() must be awaited first!");
18344 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
18345 // debug statements here
18347 // uintptr_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
18349 export function Sign_clone_ptr(arg: number): number {
18350 if(!isWasmInitialized) {
18351 throw new Error("initializeWasm() must be awaited first!");
18353 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
18354 return nativeResponseValue;
18356 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
18358 export function Sign_clone(orig: number): number {
18359 if(!isWasmInitialized) {
18360 throw new Error("initializeWasm() must be awaited first!");
18362 const nativeResponseValue = wasm.TS_Sign_clone(orig);
18363 return nativeResponseValue;
18365 // void Sign_free(struct LDKSign this_ptr);
18367 export function Sign_free(this_ptr: number): void {
18368 if(!isWasmInitialized) {
18369 throw new Error("initializeWasm() must be awaited first!");
18371 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
18372 // debug statements here
18374 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
18376 export function Recipient_clone(orig: number): Recipient {
18377 if(!isWasmInitialized) {
18378 throw new Error("initializeWasm() must be awaited first!");
18380 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
18381 return nativeResponseValue;
18383 // enum LDKRecipient Recipient_node(void);
18385 export function Recipient_node(): Recipient {
18386 if(!isWasmInitialized) {
18387 throw new Error("initializeWasm() must be awaited first!");
18389 const nativeResponseValue = wasm.TS_Recipient_node();
18390 return nativeResponseValue;
18392 // enum LDKRecipient Recipient_phantom_node(void);
18394 export function Recipient_phantom_node(): Recipient {
18395 if(!isWasmInitialized) {
18396 throw new Error("initializeWasm() must be awaited first!");
18398 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
18399 return nativeResponseValue;
18401 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
18403 export function KeysInterface_free(this_ptr: number): void {
18404 if(!isWasmInitialized) {
18405 throw new Error("initializeWasm() must be awaited first!");
18407 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
18408 // debug statements here
18410 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
18412 export function InMemorySigner_free(this_obj: number): void {
18413 if(!isWasmInitialized) {
18414 throw new Error("initializeWasm() must be awaited first!");
18416 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
18417 // debug statements here
18419 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18421 export function InMemorySigner_get_funding_key(this_ptr: number): number {
18422 if(!isWasmInitialized) {
18423 throw new Error("initializeWasm() must be awaited first!");
18425 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
18426 return nativeResponseValue;
18428 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18430 export function InMemorySigner_set_funding_key(this_ptr: number, val: number): void {
18431 if(!isWasmInitialized) {
18432 throw new Error("initializeWasm() must be awaited first!");
18434 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
18435 // debug statements here
18437 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18439 export function InMemorySigner_get_revocation_base_key(this_ptr: number): number {
18440 if(!isWasmInitialized) {
18441 throw new Error("initializeWasm() must be awaited first!");
18443 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
18444 return nativeResponseValue;
18446 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18448 export function InMemorySigner_set_revocation_base_key(this_ptr: number, val: number): void {
18449 if(!isWasmInitialized) {
18450 throw new Error("initializeWasm() must be awaited first!");
18452 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
18453 // debug statements here
18455 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18457 export function InMemorySigner_get_payment_key(this_ptr: number): number {
18458 if(!isWasmInitialized) {
18459 throw new Error("initializeWasm() must be awaited first!");
18461 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
18462 return nativeResponseValue;
18464 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18466 export function InMemorySigner_set_payment_key(this_ptr: number, val: number): void {
18467 if(!isWasmInitialized) {
18468 throw new Error("initializeWasm() must be awaited first!");
18470 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
18471 // debug statements here
18473 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18475 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): number {
18476 if(!isWasmInitialized) {
18477 throw new Error("initializeWasm() must be awaited first!");
18479 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
18480 return nativeResponseValue;
18482 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18484 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: number, val: number): void {
18485 if(!isWasmInitialized) {
18486 throw new Error("initializeWasm() must be awaited first!");
18488 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
18489 // debug statements here
18491 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18493 export function InMemorySigner_get_htlc_base_key(this_ptr: number): number {
18494 if(!isWasmInitialized) {
18495 throw new Error("initializeWasm() must be awaited first!");
18497 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
18498 return nativeResponseValue;
18500 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18502 export function InMemorySigner_set_htlc_base_key(this_ptr: number, val: number): void {
18503 if(!isWasmInitialized) {
18504 throw new Error("initializeWasm() must be awaited first!");
18506 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
18507 // debug statements here
18509 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18511 export function InMemorySigner_get_commitment_seed(this_ptr: number): number {
18512 if(!isWasmInitialized) {
18513 throw new Error("initializeWasm() must be awaited first!");
18515 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
18516 return nativeResponseValue;
18518 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18520 export function InMemorySigner_set_commitment_seed(this_ptr: number, val: number): void {
18521 if(!isWasmInitialized) {
18522 throw new Error("initializeWasm() must be awaited first!");
18524 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
18525 // debug statements here
18527 // uintptr_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
18529 export function InMemorySigner_clone_ptr(arg: number): number {
18530 if(!isWasmInitialized) {
18531 throw new Error("initializeWasm() must be awaited first!");
18533 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
18534 return nativeResponseValue;
18536 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
18538 export function InMemorySigner_clone(orig: number): number {
18539 if(!isWasmInitialized) {
18540 throw new Error("initializeWasm() must be awaited first!");
18542 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
18543 return nativeResponseValue;
18545 // 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);
18547 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 {
18548 if(!isWasmInitialized) {
18549 throw new Error("initializeWasm() must be awaited first!");
18551 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);
18552 return nativeResponseValue;
18554 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18556 export function InMemorySigner_counterparty_pubkeys(this_arg: number): number {
18557 if(!isWasmInitialized) {
18558 throw new Error("initializeWasm() must be awaited first!");
18560 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
18561 return nativeResponseValue;
18563 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18565 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number {
18566 if(!isWasmInitialized) {
18567 throw new Error("initializeWasm() must be awaited first!");
18569 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
18570 return nativeResponseValue;
18572 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18574 export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number {
18575 if(!isWasmInitialized) {
18576 throw new Error("initializeWasm() must be awaited first!");
18578 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
18579 return nativeResponseValue;
18581 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18583 export function InMemorySigner_is_outbound(this_arg: number): boolean {
18584 if(!isWasmInitialized) {
18585 throw new Error("initializeWasm() must be awaited first!");
18587 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
18588 return nativeResponseValue;
18590 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18592 export function InMemorySigner_funding_outpoint(this_arg: number): number {
18593 if(!isWasmInitialized) {
18594 throw new Error("initializeWasm() must be awaited first!");
18596 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
18597 return nativeResponseValue;
18599 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18601 export function InMemorySigner_get_channel_parameters(this_arg: number): number {
18602 if(!isWasmInitialized) {
18603 throw new Error("initializeWasm() must be awaited first!");
18605 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
18606 return nativeResponseValue;
18608 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18610 export function InMemorySigner_opt_anchors(this_arg: number): boolean {
18611 if(!isWasmInitialized) {
18612 throw new Error("initializeWasm() must be awaited first!");
18614 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
18615 return nativeResponseValue;
18617 // 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);
18619 export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
18620 if(!isWasmInitialized) {
18621 throw new Error("initializeWasm() must be awaited first!");
18623 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
18624 return nativeResponseValue;
18626 // 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);
18628 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
18629 if(!isWasmInitialized) {
18630 throw new Error("initializeWasm() must be awaited first!");
18632 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
18633 return nativeResponseValue;
18635 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18637 export function InMemorySigner_as_BaseSign(this_arg: number): number {
18638 if(!isWasmInitialized) {
18639 throw new Error("initializeWasm() must be awaited first!");
18641 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
18642 return nativeResponseValue;
18644 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18646 export function InMemorySigner_as_Sign(this_arg: number): number {
18647 if(!isWasmInitialized) {
18648 throw new Error("initializeWasm() must be awaited first!");
18650 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
18651 return nativeResponseValue;
18653 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
18655 export function InMemorySigner_write(obj: number): number {
18656 if(!isWasmInitialized) {
18657 throw new Error("initializeWasm() must be awaited first!");
18659 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
18660 return nativeResponseValue;
18662 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
18664 export function InMemorySigner_read(ser: number, arg: number): number {
18665 if(!isWasmInitialized) {
18666 throw new Error("initializeWasm() must be awaited first!");
18668 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
18669 return nativeResponseValue;
18671 // void KeysManager_free(struct LDKKeysManager this_obj);
18673 export function KeysManager_free(this_obj: number): void {
18674 if(!isWasmInitialized) {
18675 throw new Error("initializeWasm() must be awaited first!");
18677 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
18678 // debug statements here
18680 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
18682 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): number {
18683 if(!isWasmInitialized) {
18684 throw new Error("initializeWasm() must be awaited first!");
18686 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
18687 return nativeResponseValue;
18689 // 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]);
18691 export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
18692 if(!isWasmInitialized) {
18693 throw new Error("initializeWasm() must be awaited first!");
18695 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
18696 return nativeResponseValue;
18698 // 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);
18700 export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
18701 if(!isWasmInitialized) {
18702 throw new Error("initializeWasm() must be awaited first!");
18704 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
18705 return nativeResponseValue;
18707 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
18709 export function KeysManager_as_KeysInterface(this_arg: number): number {
18710 if(!isWasmInitialized) {
18711 throw new Error("initializeWasm() must be awaited first!");
18713 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
18714 return nativeResponseValue;
18716 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
18718 export function PhantomKeysManager_free(this_obj: number): void {
18719 if(!isWasmInitialized) {
18720 throw new Error("initializeWasm() must be awaited first!");
18722 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
18723 // debug statements here
18725 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
18727 export function PhantomKeysManager_as_KeysInterface(this_arg: number): number {
18728 if(!isWasmInitialized) {
18729 throw new Error("initializeWasm() must be awaited first!");
18731 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
18732 return nativeResponseValue;
18734 // 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]);
18736 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): number {
18737 if(!isWasmInitialized) {
18738 throw new Error("initializeWasm() must be awaited first!");
18740 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
18741 return nativeResponseValue;
18743 // 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);
18745 export function PhantomKeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
18746 if(!isWasmInitialized) {
18747 throw new Error("initializeWasm() must be awaited first!");
18749 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
18750 return nativeResponseValue;
18752 // 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]);
18754 export function PhantomKeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
18755 if(!isWasmInitialized) {
18756 throw new Error("initializeWasm() must be awaited first!");
18758 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
18759 return nativeResponseValue;
18761 // void ChannelManager_free(struct LDKChannelManager this_obj);
18763 export function ChannelManager_free(this_obj: number): void {
18764 if(!isWasmInitialized) {
18765 throw new Error("initializeWasm() must be awaited first!");
18767 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
18768 // debug statements here
18770 // void ChainParameters_free(struct LDKChainParameters this_obj);
18772 export function ChainParameters_free(this_obj: number): void {
18773 if(!isWasmInitialized) {
18774 throw new Error("initializeWasm() must be awaited first!");
18776 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
18777 // debug statements here
18779 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
18781 export function ChainParameters_get_network(this_ptr: number): Network {
18782 if(!isWasmInitialized) {
18783 throw new Error("initializeWasm() must be awaited first!");
18785 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
18786 return nativeResponseValue;
18788 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
18790 export function ChainParameters_set_network(this_ptr: number, val: Network): void {
18791 if(!isWasmInitialized) {
18792 throw new Error("initializeWasm() must be awaited first!");
18794 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
18795 // debug statements here
18797 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
18799 export function ChainParameters_get_best_block(this_ptr: number): number {
18800 if(!isWasmInitialized) {
18801 throw new Error("initializeWasm() must be awaited first!");
18803 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
18804 return nativeResponseValue;
18806 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
18808 export function ChainParameters_set_best_block(this_ptr: number, val: number): void {
18809 if(!isWasmInitialized) {
18810 throw new Error("initializeWasm() must be awaited first!");
18812 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
18813 // debug statements here
18815 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
18817 export function ChainParameters_new(network_arg: Network, best_block_arg: number): number {
18818 if(!isWasmInitialized) {
18819 throw new Error("initializeWasm() must be awaited first!");
18821 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
18822 return nativeResponseValue;
18824 // uintptr_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
18826 export function ChainParameters_clone_ptr(arg: number): number {
18827 if(!isWasmInitialized) {
18828 throw new Error("initializeWasm() must be awaited first!");
18830 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
18831 return nativeResponseValue;
18833 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
18835 export function ChainParameters_clone(orig: number): number {
18836 if(!isWasmInitialized) {
18837 throw new Error("initializeWasm() must be awaited first!");
18839 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
18840 return nativeResponseValue;
18842 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
18844 export function CounterpartyForwardingInfo_free(this_obj: number): void {
18845 if(!isWasmInitialized) {
18846 throw new Error("initializeWasm() must be awaited first!");
18848 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
18849 // debug statements here
18851 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18853 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: number): number {
18854 if(!isWasmInitialized) {
18855 throw new Error("initializeWasm() must be awaited first!");
18857 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
18858 return nativeResponseValue;
18860 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
18862 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: number, val: number): void {
18863 if(!isWasmInitialized) {
18864 throw new Error("initializeWasm() must be awaited first!");
18866 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
18867 // debug statements here
18869 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18871 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: number): number {
18872 if(!isWasmInitialized) {
18873 throw new Error("initializeWasm() must be awaited first!");
18875 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
18876 return nativeResponseValue;
18878 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
18880 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: number, val: number): void {
18881 if(!isWasmInitialized) {
18882 throw new Error("initializeWasm() must be awaited first!");
18884 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
18885 // debug statements here
18887 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18889 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: number): number {
18890 if(!isWasmInitialized) {
18891 throw new Error("initializeWasm() must be awaited first!");
18893 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
18894 return nativeResponseValue;
18896 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
18898 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
18899 if(!isWasmInitialized) {
18900 throw new Error("initializeWasm() must be awaited first!");
18902 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
18903 // debug statements here
18905 // 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);
18907 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): number {
18908 if(!isWasmInitialized) {
18909 throw new Error("initializeWasm() must be awaited first!");
18911 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
18912 return nativeResponseValue;
18914 // uintptr_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
18916 export function CounterpartyForwardingInfo_clone_ptr(arg: number): number {
18917 if(!isWasmInitialized) {
18918 throw new Error("initializeWasm() must be awaited first!");
18920 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
18921 return nativeResponseValue;
18923 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
18925 export function CounterpartyForwardingInfo_clone(orig: number): number {
18926 if(!isWasmInitialized) {
18927 throw new Error("initializeWasm() must be awaited first!");
18929 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
18930 return nativeResponseValue;
18932 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
18934 export function ChannelCounterparty_free(this_obj: number): void {
18935 if(!isWasmInitialized) {
18936 throw new Error("initializeWasm() must be awaited first!");
18938 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
18939 // debug statements here
18941 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18943 export function ChannelCounterparty_get_node_id(this_ptr: number): number {
18944 if(!isWasmInitialized) {
18945 throw new Error("initializeWasm() must be awaited first!");
18947 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
18948 return nativeResponseValue;
18950 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18952 export function ChannelCounterparty_set_node_id(this_ptr: number, val: number): void {
18953 if(!isWasmInitialized) {
18954 throw new Error("initializeWasm() must be awaited first!");
18956 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
18957 // debug statements here
18959 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18961 export function ChannelCounterparty_get_features(this_ptr: number): number {
18962 if(!isWasmInitialized) {
18963 throw new Error("initializeWasm() must be awaited first!");
18965 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
18966 return nativeResponseValue;
18968 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
18970 export function ChannelCounterparty_set_features(this_ptr: number, val: number): void {
18971 if(!isWasmInitialized) {
18972 throw new Error("initializeWasm() must be awaited first!");
18974 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
18975 // debug statements here
18977 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18979 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: number): bigint {
18980 if(!isWasmInitialized) {
18981 throw new Error("initializeWasm() must be awaited first!");
18983 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
18984 return nativeResponseValue;
18986 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
18988 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: number, val: bigint): void {
18989 if(!isWasmInitialized) {
18990 throw new Error("initializeWasm() must be awaited first!");
18992 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
18993 // debug statements here
18995 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18997 export function ChannelCounterparty_get_forwarding_info(this_ptr: number): number {
18998 if(!isWasmInitialized) {
18999 throw new Error("initializeWasm() must be awaited first!");
19001 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
19002 return nativeResponseValue;
19004 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
19006 export function ChannelCounterparty_set_forwarding_info(this_ptr: number, val: number): void {
19007 if(!isWasmInitialized) {
19008 throw new Error("initializeWasm() must be awaited first!");
19010 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
19011 // debug statements here
19013 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19015 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: number): number {
19016 if(!isWasmInitialized) {
19017 throw new Error("initializeWasm() must be awaited first!");
19019 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
19020 return nativeResponseValue;
19022 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19024 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: number, val: number): void {
19025 if(!isWasmInitialized) {
19026 throw new Error("initializeWasm() must be awaited first!");
19028 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
19029 // debug statements here
19031 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19033 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: number): number {
19034 if(!isWasmInitialized) {
19035 throw new Error("initializeWasm() must be awaited first!");
19037 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
19038 return nativeResponseValue;
19040 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19042 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: number, val: number): void {
19043 if(!isWasmInitialized) {
19044 throw new Error("initializeWasm() must be awaited first!");
19046 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
19047 // debug statements here
19049 // 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);
19051 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 {
19052 if(!isWasmInitialized) {
19053 throw new Error("initializeWasm() must be awaited first!");
19055 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);
19056 return nativeResponseValue;
19058 // uintptr_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
19060 export function ChannelCounterparty_clone_ptr(arg: number): number {
19061 if(!isWasmInitialized) {
19062 throw new Error("initializeWasm() must be awaited first!");
19064 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
19065 return nativeResponseValue;
19067 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
19069 export function ChannelCounterparty_clone(orig: number): number {
19070 if(!isWasmInitialized) {
19071 throw new Error("initializeWasm() must be awaited first!");
19073 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
19074 return nativeResponseValue;
19076 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
19078 export function ChannelDetails_free(this_obj: number): void {
19079 if(!isWasmInitialized) {
19080 throw new Error("initializeWasm() must be awaited first!");
19082 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
19083 // debug statements here
19085 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
19087 export function ChannelDetails_get_channel_id(this_ptr: number): number {
19088 if(!isWasmInitialized) {
19089 throw new Error("initializeWasm() must be awaited first!");
19091 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
19092 return nativeResponseValue;
19094 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19096 export function ChannelDetails_set_channel_id(this_ptr: number, val: number): void {
19097 if(!isWasmInitialized) {
19098 throw new Error("initializeWasm() must be awaited first!");
19100 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
19101 // debug statements here
19103 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19105 export function ChannelDetails_get_counterparty(this_ptr: number): number {
19106 if(!isWasmInitialized) {
19107 throw new Error("initializeWasm() must be awaited first!");
19109 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
19110 return nativeResponseValue;
19112 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
19114 export function ChannelDetails_set_counterparty(this_ptr: number, val: number): void {
19115 if(!isWasmInitialized) {
19116 throw new Error("initializeWasm() must be awaited first!");
19118 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
19119 // debug statements here
19121 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19123 export function ChannelDetails_get_funding_txo(this_ptr: number): number {
19124 if(!isWasmInitialized) {
19125 throw new Error("initializeWasm() must be awaited first!");
19127 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
19128 return nativeResponseValue;
19130 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
19132 export function ChannelDetails_set_funding_txo(this_ptr: number, val: number): void {
19133 if(!isWasmInitialized) {
19134 throw new Error("initializeWasm() must be awaited first!");
19136 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
19137 // debug statements here
19139 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19141 export function ChannelDetails_get_channel_type(this_ptr: number): number {
19142 if(!isWasmInitialized) {
19143 throw new Error("initializeWasm() must be awaited first!");
19145 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
19146 return nativeResponseValue;
19148 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
19150 export function ChannelDetails_set_channel_type(this_ptr: number, val: number): void {
19151 if(!isWasmInitialized) {
19152 throw new Error("initializeWasm() must be awaited first!");
19154 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
19155 // debug statements here
19157 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19159 export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
19160 if(!isWasmInitialized) {
19161 throw new Error("initializeWasm() must be awaited first!");
19163 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
19164 return nativeResponseValue;
19166 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19168 export function ChannelDetails_set_short_channel_id(this_ptr: number, val: number): void {
19169 if(!isWasmInitialized) {
19170 throw new Error("initializeWasm() must be awaited first!");
19172 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
19173 // debug statements here
19175 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19177 export function ChannelDetails_get_outbound_scid_alias(this_ptr: number): number {
19178 if(!isWasmInitialized) {
19179 throw new Error("initializeWasm() must be awaited first!");
19181 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
19182 return nativeResponseValue;
19184 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19186 export function ChannelDetails_set_outbound_scid_alias(this_ptr: number, val: number): void {
19187 if(!isWasmInitialized) {
19188 throw new Error("initializeWasm() must be awaited first!");
19190 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
19191 // debug statements here
19193 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19195 export function ChannelDetails_get_inbound_scid_alias(this_ptr: number): number {
19196 if(!isWasmInitialized) {
19197 throw new Error("initializeWasm() must be awaited first!");
19199 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
19200 return nativeResponseValue;
19202 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19204 export function ChannelDetails_set_inbound_scid_alias(this_ptr: number, val: number): void {
19205 if(!isWasmInitialized) {
19206 throw new Error("initializeWasm() must be awaited first!");
19208 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
19209 // debug statements here
19211 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19213 export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): bigint {
19214 if(!isWasmInitialized) {
19215 throw new Error("initializeWasm() must be awaited first!");
19217 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
19218 return nativeResponseValue;
19220 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19222 export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
19223 if(!isWasmInitialized) {
19224 throw new Error("initializeWasm() must be awaited first!");
19226 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
19227 // debug statements here
19229 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19231 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: number): number {
19232 if(!isWasmInitialized) {
19233 throw new Error("initializeWasm() must be awaited first!");
19235 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
19236 return nativeResponseValue;
19238 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19240 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: number, val: number): void {
19241 if(!isWasmInitialized) {
19242 throw new Error("initializeWasm() must be awaited first!");
19244 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
19245 // debug statements here
19247 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19249 export function ChannelDetails_get_user_channel_id(this_ptr: number): bigint {
19250 if(!isWasmInitialized) {
19251 throw new Error("initializeWasm() must be awaited first!");
19253 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
19254 return nativeResponseValue;
19256 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19258 export function ChannelDetails_set_user_channel_id(this_ptr: number, val: bigint): void {
19259 if(!isWasmInitialized) {
19260 throw new Error("initializeWasm() must be awaited first!");
19262 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
19263 // debug statements here
19265 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19267 export function ChannelDetails_get_balance_msat(this_ptr: number): bigint {
19268 if(!isWasmInitialized) {
19269 throw new Error("initializeWasm() must be awaited first!");
19271 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
19272 return nativeResponseValue;
19274 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19276 export function ChannelDetails_set_balance_msat(this_ptr: number, val: bigint): void {
19277 if(!isWasmInitialized) {
19278 throw new Error("initializeWasm() must be awaited first!");
19280 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
19281 // debug statements here
19283 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19285 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: number): bigint {
19286 if(!isWasmInitialized) {
19287 throw new Error("initializeWasm() must be awaited first!");
19289 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
19290 return nativeResponseValue;
19292 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19294 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: number, val: bigint): void {
19295 if(!isWasmInitialized) {
19296 throw new Error("initializeWasm() must be awaited first!");
19298 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
19299 // debug statements here
19301 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19303 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: number): bigint {
19304 if(!isWasmInitialized) {
19305 throw new Error("initializeWasm() must be awaited first!");
19307 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
19308 return nativeResponseValue;
19310 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19312 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: number, val: bigint): void {
19313 if(!isWasmInitialized) {
19314 throw new Error("initializeWasm() must be awaited first!");
19316 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
19317 // debug statements here
19319 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19321 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: number): bigint {
19322 if(!isWasmInitialized) {
19323 throw new Error("initializeWasm() must be awaited first!");
19325 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
19326 return nativeResponseValue;
19328 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19330 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: number, val: bigint): void {
19331 if(!isWasmInitialized) {
19332 throw new Error("initializeWasm() must be awaited first!");
19334 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
19335 // debug statements here
19337 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19339 export function ChannelDetails_get_confirmations_required(this_ptr: number): number {
19340 if(!isWasmInitialized) {
19341 throw new Error("initializeWasm() must be awaited first!");
19343 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
19344 return nativeResponseValue;
19346 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
19348 export function ChannelDetails_set_confirmations_required(this_ptr: number, val: number): void {
19349 if(!isWasmInitialized) {
19350 throw new Error("initializeWasm() must be awaited first!");
19352 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
19353 // debug statements here
19355 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19357 export function ChannelDetails_get_force_close_spend_delay(this_ptr: number): number {
19358 if(!isWasmInitialized) {
19359 throw new Error("initializeWasm() must be awaited first!");
19361 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
19362 return nativeResponseValue;
19364 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
19366 export function ChannelDetails_set_force_close_spend_delay(this_ptr: number, val: number): void {
19367 if(!isWasmInitialized) {
19368 throw new Error("initializeWasm() must be awaited first!");
19370 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
19371 // debug statements here
19373 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19375 export function ChannelDetails_get_is_outbound(this_ptr: number): boolean {
19376 if(!isWasmInitialized) {
19377 throw new Error("initializeWasm() must be awaited first!");
19379 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
19380 return nativeResponseValue;
19382 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19384 export function ChannelDetails_set_is_outbound(this_ptr: number, val: boolean): void {
19385 if(!isWasmInitialized) {
19386 throw new Error("initializeWasm() must be awaited first!");
19388 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
19389 // debug statements here
19391 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19393 export function ChannelDetails_get_is_channel_ready(this_ptr: number): boolean {
19394 if(!isWasmInitialized) {
19395 throw new Error("initializeWasm() must be awaited first!");
19397 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
19398 return nativeResponseValue;
19400 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19402 export function ChannelDetails_set_is_channel_ready(this_ptr: number, val: boolean): void {
19403 if(!isWasmInitialized) {
19404 throw new Error("initializeWasm() must be awaited first!");
19406 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
19407 // debug statements here
19409 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19411 export function ChannelDetails_get_is_usable(this_ptr: number): boolean {
19412 if(!isWasmInitialized) {
19413 throw new Error("initializeWasm() must be awaited first!");
19415 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
19416 return nativeResponseValue;
19418 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19420 export function ChannelDetails_set_is_usable(this_ptr: number, val: boolean): void {
19421 if(!isWasmInitialized) {
19422 throw new Error("initializeWasm() must be awaited first!");
19424 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
19425 // debug statements here
19427 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19429 export function ChannelDetails_get_is_public(this_ptr: number): boolean {
19430 if(!isWasmInitialized) {
19431 throw new Error("initializeWasm() must be awaited first!");
19433 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
19434 return nativeResponseValue;
19436 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19438 export function ChannelDetails_set_is_public(this_ptr: number, val: boolean): void {
19439 if(!isWasmInitialized) {
19440 throw new Error("initializeWasm() must be awaited first!");
19442 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
19443 // debug statements here
19445 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19447 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: number): number {
19448 if(!isWasmInitialized) {
19449 throw new Error("initializeWasm() must be awaited first!");
19451 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
19452 return nativeResponseValue;
19454 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19456 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: number, val: number): void {
19457 if(!isWasmInitialized) {
19458 throw new Error("initializeWasm() must be awaited first!");
19460 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
19461 // debug statements here
19463 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19465 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: number): number {
19466 if(!isWasmInitialized) {
19467 throw new Error("initializeWasm() must be awaited first!");
19469 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
19470 return nativeResponseValue;
19472 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19474 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: number, val: number): void {
19475 if(!isWasmInitialized) {
19476 throw new Error("initializeWasm() must be awaited first!");
19478 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
19479 // debug statements here
19481 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19483 export function ChannelDetails_get_config(this_ptr: number): number {
19484 if(!isWasmInitialized) {
19485 throw new Error("initializeWasm() must be awaited first!");
19487 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
19488 return nativeResponseValue;
19490 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
19492 export function ChannelDetails_set_config(this_ptr: number, val: number): void {
19493 if(!isWasmInitialized) {
19494 throw new Error("initializeWasm() must be awaited first!");
19496 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
19497 // debug statements here
19499 // 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);
19501 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 {
19502 if(!isWasmInitialized) {
19503 throw new Error("initializeWasm() must be awaited first!");
19505 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);
19506 return nativeResponseValue;
19508 // uintptr_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
19510 export function ChannelDetails_clone_ptr(arg: number): number {
19511 if(!isWasmInitialized) {
19512 throw new Error("initializeWasm() must be awaited first!");
19514 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
19515 return nativeResponseValue;
19517 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
19519 export function ChannelDetails_clone(orig: number): number {
19520 if(!isWasmInitialized) {
19521 throw new Error("initializeWasm() must be awaited first!");
19523 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
19524 return nativeResponseValue;
19526 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
19528 export function ChannelDetails_get_inbound_payment_scid(this_arg: number): number {
19529 if(!isWasmInitialized) {
19530 throw new Error("initializeWasm() must be awaited first!");
19532 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
19533 return nativeResponseValue;
19535 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
19537 export function ChannelDetails_get_outbound_payment_scid(this_arg: number): number {
19538 if(!isWasmInitialized) {
19539 throw new Error("initializeWasm() must be awaited first!");
19541 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
19542 return nativeResponseValue;
19544 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
19546 export function PaymentSendFailure_free(this_ptr: number): void {
19547 if(!isWasmInitialized) {
19548 throw new Error("initializeWasm() must be awaited first!");
19550 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
19551 // debug statements here
19553 // uintptr_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
19555 export function PaymentSendFailure_clone_ptr(arg: number): number {
19556 if(!isWasmInitialized) {
19557 throw new Error("initializeWasm() must be awaited first!");
19559 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
19560 return nativeResponseValue;
19562 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
19564 export function PaymentSendFailure_clone(orig: number): number {
19565 if(!isWasmInitialized) {
19566 throw new Error("initializeWasm() must be awaited first!");
19568 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
19569 return nativeResponseValue;
19571 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
19573 export function PaymentSendFailure_parameter_error(a: number): number {
19574 if(!isWasmInitialized) {
19575 throw new Error("initializeWasm() must be awaited first!");
19577 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
19578 return nativeResponseValue;
19580 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
19582 export function PaymentSendFailure_path_parameter_error(a: number): number {
19583 if(!isWasmInitialized) {
19584 throw new Error("initializeWasm() must be awaited first!");
19586 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
19587 return nativeResponseValue;
19589 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
19591 export function PaymentSendFailure_all_failed_retry_safe(a: number): number {
19592 if(!isWasmInitialized) {
19593 throw new Error("initializeWasm() must be awaited first!");
19595 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
19596 return nativeResponseValue;
19598 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
19600 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: number, payment_id: number): number {
19601 if(!isWasmInitialized) {
19602 throw new Error("initializeWasm() must be awaited first!");
19604 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
19605 return nativeResponseValue;
19607 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
19609 export function PhantomRouteHints_free(this_obj: number): void {
19610 if(!isWasmInitialized) {
19611 throw new Error("initializeWasm() must be awaited first!");
19613 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
19614 // debug statements here
19616 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
19618 export function PhantomRouteHints_get_channels(this_ptr: number): number {
19619 if(!isWasmInitialized) {
19620 throw new Error("initializeWasm() must be awaited first!");
19622 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
19623 return nativeResponseValue;
19625 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
19627 export function PhantomRouteHints_set_channels(this_ptr: number, val: number): void {
19628 if(!isWasmInitialized) {
19629 throw new Error("initializeWasm() must be awaited first!");
19631 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
19632 // debug statements here
19634 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
19636 export function PhantomRouteHints_get_phantom_scid(this_ptr: number): bigint {
19637 if(!isWasmInitialized) {
19638 throw new Error("initializeWasm() must be awaited first!");
19640 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
19641 return nativeResponseValue;
19643 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
19645 export function PhantomRouteHints_set_phantom_scid(this_ptr: number, val: bigint): void {
19646 if(!isWasmInitialized) {
19647 throw new Error("initializeWasm() must be awaited first!");
19649 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
19650 // debug statements here
19652 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
19654 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: number): number {
19655 if(!isWasmInitialized) {
19656 throw new Error("initializeWasm() must be awaited first!");
19658 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
19659 return nativeResponseValue;
19661 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19663 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: number, val: number): void {
19664 if(!isWasmInitialized) {
19665 throw new Error("initializeWasm() must be awaited first!");
19667 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
19668 // debug statements here
19670 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
19672 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): number {
19673 if(!isWasmInitialized) {
19674 throw new Error("initializeWasm() must be awaited first!");
19676 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
19677 return nativeResponseValue;
19679 // uintptr_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
19681 export function PhantomRouteHints_clone_ptr(arg: number): number {
19682 if(!isWasmInitialized) {
19683 throw new Error("initializeWasm() must be awaited first!");
19685 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
19686 return nativeResponseValue;
19688 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
19690 export function PhantomRouteHints_clone(orig: number): number {
19691 if(!isWasmInitialized) {
19692 throw new Error("initializeWasm() must be awaited first!");
19694 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
19695 return nativeResponseValue;
19697 // 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);
19699 export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
19700 if(!isWasmInitialized) {
19701 throw new Error("initializeWasm() must be awaited first!");
19703 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
19704 return nativeResponseValue;
19706 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
19708 export function ChannelManager_get_current_default_configuration(this_arg: number): number {
19709 if(!isWasmInitialized) {
19710 throw new Error("initializeWasm() must be awaited first!");
19712 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
19713 return nativeResponseValue;
19715 // 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);
19717 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 {
19718 if(!isWasmInitialized) {
19719 throw new Error("initializeWasm() must be awaited first!");
19721 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
19722 return nativeResponseValue;
19724 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
19726 export function ChannelManager_list_channels(this_arg: number): number {
19727 if(!isWasmInitialized) {
19728 throw new Error("initializeWasm() must be awaited first!");
19730 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
19731 return nativeResponseValue;
19733 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
19735 export function ChannelManager_list_usable_channels(this_arg: number): number {
19736 if(!isWasmInitialized) {
19737 throw new Error("initializeWasm() must be awaited first!");
19739 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
19740 return nativeResponseValue;
19742 // 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);
19744 export function ChannelManager_close_channel(this_arg: number, channel_id: number, counterparty_node_id: number): number {
19745 if(!isWasmInitialized) {
19746 throw new Error("initializeWasm() must be awaited first!");
19748 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
19749 return nativeResponseValue;
19751 // 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);
19753 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 {
19754 if(!isWasmInitialized) {
19755 throw new Error("initializeWasm() must be awaited first!");
19757 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight);
19758 return nativeResponseValue;
19760 // 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);
19762 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: number, channel_id: number, counterparty_node_id: number): number {
19763 if(!isWasmInitialized) {
19764 throw new Error("initializeWasm() must be awaited first!");
19766 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
19767 return nativeResponseValue;
19769 // 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);
19771 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: number, channel_id: number, counterparty_node_id: number): number {
19772 if(!isWasmInitialized) {
19773 throw new Error("initializeWasm() must be awaited first!");
19775 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
19776 return nativeResponseValue;
19778 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
19780 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: number): void {
19781 if(!isWasmInitialized) {
19782 throw new Error("initializeWasm() must be awaited first!");
19784 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
19785 // debug statements here
19787 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
19789 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: number): void {
19790 if(!isWasmInitialized) {
19791 throw new Error("initializeWasm() must be awaited first!");
19793 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
19794 // debug statements here
19796 // 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);
19798 export function ChannelManager_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
19799 if(!isWasmInitialized) {
19800 throw new Error("initializeWasm() must be awaited first!");
19802 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
19803 return nativeResponseValue;
19805 // 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);
19807 export function ChannelManager_retry_payment(this_arg: number, route: number, payment_id: number): number {
19808 if(!isWasmInitialized) {
19809 throw new Error("initializeWasm() must be awaited first!");
19811 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
19812 return nativeResponseValue;
19814 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
19816 export function ChannelManager_abandon_payment(this_arg: number, payment_id: number): void {
19817 if(!isWasmInitialized) {
19818 throw new Error("initializeWasm() must be awaited first!");
19820 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
19821 // debug statements here
19823 // 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);
19825 export function ChannelManager_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
19826 if(!isWasmInitialized) {
19827 throw new Error("initializeWasm() must be awaited first!");
19829 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
19830 return nativeResponseValue;
19832 // 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);
19834 export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): number {
19835 if(!isWasmInitialized) {
19836 throw new Error("initializeWasm() must be awaited first!");
19838 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
19839 return nativeResponseValue;
19841 // void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
19843 export function ChannelManager_broadcast_node_announcement(this_arg: number, rgb: number, alias: number, addresses: number): void {
19844 if(!isWasmInitialized) {
19845 throw new Error("initializeWasm() must be awaited first!");
19847 const nativeResponseValue = wasm.TS_ChannelManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
19848 // debug statements here
19850 // 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);
19852 export function ChannelManager_update_channel_config(this_arg: number, counterparty_node_id: number, channel_ids: number, config: number): number {
19853 if(!isWasmInitialized) {
19854 throw new Error("initializeWasm() must be awaited first!");
19856 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
19857 return nativeResponseValue;
19859 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
19861 export function ChannelManager_process_pending_htlc_forwards(this_arg: number): void {
19862 if(!isWasmInitialized) {
19863 throw new Error("initializeWasm() must be awaited first!");
19865 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
19866 // debug statements here
19868 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
19870 export function ChannelManager_timer_tick_occurred(this_arg: number): void {
19871 if(!isWasmInitialized) {
19872 throw new Error("initializeWasm() must be awaited first!");
19874 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
19875 // debug statements here
19877 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
19879 export function ChannelManager_fail_htlc_backwards(this_arg: number, payment_hash: number): void {
19880 if(!isWasmInitialized) {
19881 throw new Error("initializeWasm() must be awaited first!");
19883 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
19884 // debug statements here
19886 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
19888 export function ChannelManager_claim_funds(this_arg: number, payment_preimage: number): void {
19889 if(!isWasmInitialized) {
19890 throw new Error("initializeWasm() must be awaited first!");
19892 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
19893 // debug statements here
19895 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
19897 export function ChannelManager_get_our_node_id(this_arg: number): number {
19898 if(!isWasmInitialized) {
19899 throw new Error("initializeWasm() must be awaited first!");
19901 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
19902 return nativeResponseValue;
19904 // 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);
19906 export function ChannelManager_accept_inbound_channel(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): number {
19907 if(!isWasmInitialized) {
19908 throw new Error("initializeWasm() must be awaited first!");
19910 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
19911 return nativeResponseValue;
19913 // 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);
19915 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 {
19916 if(!isWasmInitialized) {
19917 throw new Error("initializeWasm() must be awaited first!");
19919 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
19920 return nativeResponseValue;
19922 // 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);
19924 export function ChannelManager_create_inbound_payment(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19925 if(!isWasmInitialized) {
19926 throw new Error("initializeWasm() must be awaited first!");
19928 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
19929 return nativeResponseValue;
19931 // 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);
19933 export function ChannelManager_create_inbound_payment_legacy(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19934 if(!isWasmInitialized) {
19935 throw new Error("initializeWasm() must be awaited first!");
19937 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
19938 return nativeResponseValue;
19940 // 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);
19942 export function ChannelManager_create_inbound_payment_for_hash(this_arg: number, payment_hash: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19943 if(!isWasmInitialized) {
19944 throw new Error("initializeWasm() must be awaited first!");
19946 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
19947 return nativeResponseValue;
19949 // 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);
19951 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 {
19952 if(!isWasmInitialized) {
19953 throw new Error("initializeWasm() must be awaited first!");
19955 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
19956 return nativeResponseValue;
19958 // 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);
19960 export function ChannelManager_get_payment_preimage(this_arg: number, payment_hash: number, payment_secret: number): number {
19961 if(!isWasmInitialized) {
19962 throw new Error("initializeWasm() must be awaited first!");
19964 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
19965 return nativeResponseValue;
19967 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
19969 export function ChannelManager_get_phantom_scid(this_arg: number): bigint {
19970 if(!isWasmInitialized) {
19971 throw new Error("initializeWasm() must be awaited first!");
19973 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
19974 return nativeResponseValue;
19976 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
19978 export function ChannelManager_get_phantom_route_hints(this_arg: number): number {
19979 if(!isWasmInitialized) {
19980 throw new Error("initializeWasm() must be awaited first!");
19982 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
19983 return nativeResponseValue;
19985 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
19987 export function ChannelManager_as_MessageSendEventsProvider(this_arg: number): number {
19988 if(!isWasmInitialized) {
19989 throw new Error("initializeWasm() must be awaited first!");
19991 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
19992 return nativeResponseValue;
19994 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
19996 export function ChannelManager_as_EventsProvider(this_arg: number): number {
19997 if(!isWasmInitialized) {
19998 throw new Error("initializeWasm() must be awaited first!");
20000 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
20001 return nativeResponseValue;
20003 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
20005 export function ChannelManager_as_Listen(this_arg: number): number {
20006 if(!isWasmInitialized) {
20007 throw new Error("initializeWasm() must be awaited first!");
20009 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
20010 return nativeResponseValue;
20012 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
20014 export function ChannelManager_as_Confirm(this_arg: number): number {
20015 if(!isWasmInitialized) {
20016 throw new Error("initializeWasm() must be awaited first!");
20018 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
20019 return nativeResponseValue;
20021 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
20023 export function ChannelManager_await_persistable_update(this_arg: number): void {
20024 if(!isWasmInitialized) {
20025 throw new Error("initializeWasm() must be awaited first!");
20027 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
20028 // debug statements here
20030 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
20032 export function ChannelManager_current_best_block(this_arg: number): number {
20033 if(!isWasmInitialized) {
20034 throw new Error("initializeWasm() must be awaited first!");
20036 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
20037 return nativeResponseValue;
20039 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
20041 export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number {
20042 if(!isWasmInitialized) {
20043 throw new Error("initializeWasm() must be awaited first!");
20045 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
20046 return nativeResponseValue;
20048 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
20050 export function CounterpartyForwardingInfo_write(obj: number): number {
20051 if(!isWasmInitialized) {
20052 throw new Error("initializeWasm() must be awaited first!");
20054 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
20055 return nativeResponseValue;
20057 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
20059 export function CounterpartyForwardingInfo_read(ser: number): number {
20060 if(!isWasmInitialized) {
20061 throw new Error("initializeWasm() must be awaited first!");
20063 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
20064 return nativeResponseValue;
20066 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
20068 export function ChannelCounterparty_write(obj: number): number {
20069 if(!isWasmInitialized) {
20070 throw new Error("initializeWasm() must be awaited first!");
20072 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
20073 return nativeResponseValue;
20075 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
20077 export function ChannelCounterparty_read(ser: number): number {
20078 if(!isWasmInitialized) {
20079 throw new Error("initializeWasm() must be awaited first!");
20081 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
20082 return nativeResponseValue;
20084 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
20086 export function ChannelDetails_write(obj: number): number {
20087 if(!isWasmInitialized) {
20088 throw new Error("initializeWasm() must be awaited first!");
20090 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
20091 return nativeResponseValue;
20093 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
20095 export function ChannelDetails_read(ser: number): number {
20096 if(!isWasmInitialized) {
20097 throw new Error("initializeWasm() must be awaited first!");
20099 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
20100 return nativeResponseValue;
20102 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
20104 export function PhantomRouteHints_write(obj: number): number {
20105 if(!isWasmInitialized) {
20106 throw new Error("initializeWasm() must be awaited first!");
20108 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
20109 return nativeResponseValue;
20111 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
20113 export function PhantomRouteHints_read(ser: number): number {
20114 if(!isWasmInitialized) {
20115 throw new Error("initializeWasm() must be awaited first!");
20117 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
20118 return nativeResponseValue;
20120 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
20122 export function ChannelManager_write(obj: number): number {
20123 if(!isWasmInitialized) {
20124 throw new Error("initializeWasm() must be awaited first!");
20126 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
20127 return nativeResponseValue;
20129 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
20131 export function ChannelManagerReadArgs_free(this_obj: number): void {
20132 if(!isWasmInitialized) {
20133 throw new Error("initializeWasm() must be awaited first!");
20135 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
20136 // debug statements here
20138 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20140 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: number): number {
20141 if(!isWasmInitialized) {
20142 throw new Error("initializeWasm() must be awaited first!");
20144 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
20145 return nativeResponseValue;
20147 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
20149 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: number, val: number): void {
20150 if(!isWasmInitialized) {
20151 throw new Error("initializeWasm() must be awaited first!");
20153 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
20154 // debug statements here
20156 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20158 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: number): number {
20159 if(!isWasmInitialized) {
20160 throw new Error("initializeWasm() must be awaited first!");
20162 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
20163 return nativeResponseValue;
20165 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
20167 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: number, val: number): void {
20168 if(!isWasmInitialized) {
20169 throw new Error("initializeWasm() must be awaited first!");
20171 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
20172 // debug statements here
20174 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20176 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: number): number {
20177 if(!isWasmInitialized) {
20178 throw new Error("initializeWasm() must be awaited first!");
20180 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
20181 return nativeResponseValue;
20183 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
20185 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: number, val: number): void {
20186 if(!isWasmInitialized) {
20187 throw new Error("initializeWasm() must be awaited first!");
20189 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
20190 // debug statements here
20192 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20194 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: number): number {
20195 if(!isWasmInitialized) {
20196 throw new Error("initializeWasm() must be awaited first!");
20198 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
20199 return nativeResponseValue;
20201 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
20203 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: number, val: number): void {
20204 if(!isWasmInitialized) {
20205 throw new Error("initializeWasm() must be awaited first!");
20207 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
20208 // debug statements here
20210 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20212 export function ChannelManagerReadArgs_get_logger(this_ptr: number): number {
20213 if(!isWasmInitialized) {
20214 throw new Error("initializeWasm() must be awaited first!");
20216 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
20217 return nativeResponseValue;
20219 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
20221 export function ChannelManagerReadArgs_set_logger(this_ptr: number, val: number): void {
20222 if(!isWasmInitialized) {
20223 throw new Error("initializeWasm() must be awaited first!");
20225 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
20226 // debug statements here
20228 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20230 export function ChannelManagerReadArgs_get_default_config(this_ptr: number): number {
20231 if(!isWasmInitialized) {
20232 throw new Error("initializeWasm() must be awaited first!");
20234 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
20235 return nativeResponseValue;
20237 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
20239 export function ChannelManagerReadArgs_set_default_config(this_ptr: number, val: number): void {
20240 if(!isWasmInitialized) {
20241 throw new Error("initializeWasm() must be awaited first!");
20243 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
20244 // debug statements here
20246 // 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);
20248 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 {
20249 if(!isWasmInitialized) {
20250 throw new Error("initializeWasm() must be awaited first!");
20252 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
20253 return nativeResponseValue;
20255 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
20257 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: number): number {
20258 if(!isWasmInitialized) {
20259 throw new Error("initializeWasm() must be awaited first!");
20261 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
20262 return nativeResponseValue;
20264 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
20266 export function ExpandedKey_free(this_obj: number): void {
20267 if(!isWasmInitialized) {
20268 throw new Error("initializeWasm() must be awaited first!");
20270 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
20271 // debug statements here
20273 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
20275 export function ExpandedKey_new(key_material: number): number {
20276 if(!isWasmInitialized) {
20277 throw new Error("initializeWasm() must be awaited first!");
20279 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
20280 return nativeResponseValue;
20282 // 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);
20284 export function create(keys: number, min_value_msat: number, invoice_expiry_delta_secs: number, keys_manager: number, current_time: bigint): number {
20285 if(!isWasmInitialized) {
20286 throw new Error("initializeWasm() must be awaited first!");
20288 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, keys_manager, current_time);
20289 return nativeResponseValue;
20291 // 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);
20293 export function create_from_hash(keys: number, min_value_msat: number, payment_hash: number, invoice_expiry_delta_secs: number, current_time: bigint): number {
20294 if(!isWasmInitialized) {
20295 throw new Error("initializeWasm() must be awaited first!");
20297 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time);
20298 return nativeResponseValue;
20300 // void DecodeError_free(struct LDKDecodeError this_obj);
20302 export function DecodeError_free(this_obj: number): void {
20303 if(!isWasmInitialized) {
20304 throw new Error("initializeWasm() must be awaited first!");
20306 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
20307 // debug statements here
20309 // uintptr_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
20311 export function DecodeError_clone_ptr(arg: number): number {
20312 if(!isWasmInitialized) {
20313 throw new Error("initializeWasm() must be awaited first!");
20315 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
20316 return nativeResponseValue;
20318 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
20320 export function DecodeError_clone(orig: number): number {
20321 if(!isWasmInitialized) {
20322 throw new Error("initializeWasm() must be awaited first!");
20324 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
20325 return nativeResponseValue;
20327 // void Init_free(struct LDKInit this_obj);
20329 export function Init_free(this_obj: number): void {
20330 if(!isWasmInitialized) {
20331 throw new Error("initializeWasm() must be awaited first!");
20333 const nativeResponseValue = wasm.TS_Init_free(this_obj);
20334 // debug statements here
20336 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
20338 export function Init_get_features(this_ptr: number): number {
20339 if(!isWasmInitialized) {
20340 throw new Error("initializeWasm() must be awaited first!");
20342 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
20343 return nativeResponseValue;
20345 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
20347 export function Init_set_features(this_ptr: number, val: number): void {
20348 if(!isWasmInitialized) {
20349 throw new Error("initializeWasm() must be awaited first!");
20351 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
20352 // debug statements here
20354 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
20356 export function Init_get_remote_network_address(this_ptr: number): number {
20357 if(!isWasmInitialized) {
20358 throw new Error("initializeWasm() must be awaited first!");
20360 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
20361 return nativeResponseValue;
20363 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
20365 export function Init_set_remote_network_address(this_ptr: number, val: number): void {
20366 if(!isWasmInitialized) {
20367 throw new Error("initializeWasm() must be awaited first!");
20369 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
20370 // debug statements here
20372 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
20374 export function Init_new(features_arg: number, remote_network_address_arg: number): number {
20375 if(!isWasmInitialized) {
20376 throw new Error("initializeWasm() must be awaited first!");
20378 const nativeResponseValue = wasm.TS_Init_new(features_arg, remote_network_address_arg);
20379 return nativeResponseValue;
20381 // uintptr_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
20383 export function Init_clone_ptr(arg: number): number {
20384 if(!isWasmInitialized) {
20385 throw new Error("initializeWasm() must be awaited first!");
20387 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
20388 return nativeResponseValue;
20390 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
20392 export function Init_clone(orig: number): number {
20393 if(!isWasmInitialized) {
20394 throw new Error("initializeWasm() must be awaited first!");
20396 const nativeResponseValue = wasm.TS_Init_clone(orig);
20397 return nativeResponseValue;
20399 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
20401 export function ErrorMessage_free(this_obj: number): void {
20402 if(!isWasmInitialized) {
20403 throw new Error("initializeWasm() must be awaited first!");
20405 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
20406 // debug statements here
20408 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
20410 export function ErrorMessage_get_channel_id(this_ptr: number): number {
20411 if(!isWasmInitialized) {
20412 throw new Error("initializeWasm() must be awaited first!");
20414 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
20415 return nativeResponseValue;
20417 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20419 export function ErrorMessage_set_channel_id(this_ptr: number, val: number): void {
20420 if(!isWasmInitialized) {
20421 throw new Error("initializeWasm() must be awaited first!");
20423 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
20424 // debug statements here
20426 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
20428 export function ErrorMessage_get_data(this_ptr: number): number {
20429 if(!isWasmInitialized) {
20430 throw new Error("initializeWasm() must be awaited first!");
20432 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
20433 return nativeResponseValue;
20435 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20437 export function ErrorMessage_set_data(this_ptr: number, val: number): void {
20438 if(!isWasmInitialized) {
20439 throw new Error("initializeWasm() must be awaited first!");
20441 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
20442 // debug statements here
20444 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
20446 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): number {
20447 if(!isWasmInitialized) {
20448 throw new Error("initializeWasm() must be awaited first!");
20450 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
20451 return nativeResponseValue;
20453 // uintptr_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
20455 export function ErrorMessage_clone_ptr(arg: number): number {
20456 if(!isWasmInitialized) {
20457 throw new Error("initializeWasm() must be awaited first!");
20459 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
20460 return nativeResponseValue;
20462 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
20464 export function ErrorMessage_clone(orig: number): number {
20465 if(!isWasmInitialized) {
20466 throw new Error("initializeWasm() must be awaited first!");
20468 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
20469 return nativeResponseValue;
20471 // void WarningMessage_free(struct LDKWarningMessage this_obj);
20473 export function WarningMessage_free(this_obj: number): void {
20474 if(!isWasmInitialized) {
20475 throw new Error("initializeWasm() must be awaited first!");
20477 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
20478 // debug statements here
20480 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
20482 export function WarningMessage_get_channel_id(this_ptr: number): number {
20483 if(!isWasmInitialized) {
20484 throw new Error("initializeWasm() must be awaited first!");
20486 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
20487 return nativeResponseValue;
20489 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20491 export function WarningMessage_set_channel_id(this_ptr: number, val: number): void {
20492 if(!isWasmInitialized) {
20493 throw new Error("initializeWasm() must be awaited first!");
20495 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
20496 // debug statements here
20498 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
20500 export function WarningMessage_get_data(this_ptr: number): number {
20501 if(!isWasmInitialized) {
20502 throw new Error("initializeWasm() must be awaited first!");
20504 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
20505 return nativeResponseValue;
20507 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20509 export function WarningMessage_set_data(this_ptr: number, val: number): void {
20510 if(!isWasmInitialized) {
20511 throw new Error("initializeWasm() must be awaited first!");
20513 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
20514 // debug statements here
20516 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
20518 export function WarningMessage_new(channel_id_arg: number, data_arg: number): number {
20519 if(!isWasmInitialized) {
20520 throw new Error("initializeWasm() must be awaited first!");
20522 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
20523 return nativeResponseValue;
20525 // uintptr_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
20527 export function WarningMessage_clone_ptr(arg: number): number {
20528 if(!isWasmInitialized) {
20529 throw new Error("initializeWasm() must be awaited first!");
20531 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
20532 return nativeResponseValue;
20534 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
20536 export function WarningMessage_clone(orig: number): number {
20537 if(!isWasmInitialized) {
20538 throw new Error("initializeWasm() must be awaited first!");
20540 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
20541 return nativeResponseValue;
20543 // void Ping_free(struct LDKPing this_obj);
20545 export function Ping_free(this_obj: number): void {
20546 if(!isWasmInitialized) {
20547 throw new Error("initializeWasm() must be awaited first!");
20549 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
20550 // debug statements here
20552 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
20554 export function Ping_get_ponglen(this_ptr: number): number {
20555 if(!isWasmInitialized) {
20556 throw new Error("initializeWasm() must be awaited first!");
20558 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
20559 return nativeResponseValue;
20561 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
20563 export function Ping_set_ponglen(this_ptr: number, val: number): void {
20564 if(!isWasmInitialized) {
20565 throw new Error("initializeWasm() must be awaited first!");
20567 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
20568 // debug statements here
20570 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
20572 export function Ping_get_byteslen(this_ptr: number): number {
20573 if(!isWasmInitialized) {
20574 throw new Error("initializeWasm() must be awaited first!");
20576 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
20577 return nativeResponseValue;
20579 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
20581 export function Ping_set_byteslen(this_ptr: number, val: number): void {
20582 if(!isWasmInitialized) {
20583 throw new Error("initializeWasm() must be awaited first!");
20585 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
20586 // debug statements here
20588 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
20590 export function Ping_new(ponglen_arg: number, byteslen_arg: number): number {
20591 if(!isWasmInitialized) {
20592 throw new Error("initializeWasm() must be awaited first!");
20594 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
20595 return nativeResponseValue;
20597 // uintptr_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
20599 export function Ping_clone_ptr(arg: number): number {
20600 if(!isWasmInitialized) {
20601 throw new Error("initializeWasm() must be awaited first!");
20603 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
20604 return nativeResponseValue;
20606 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
20608 export function Ping_clone(orig: number): number {
20609 if(!isWasmInitialized) {
20610 throw new Error("initializeWasm() must be awaited first!");
20612 const nativeResponseValue = wasm.TS_Ping_clone(orig);
20613 return nativeResponseValue;
20615 // void Pong_free(struct LDKPong this_obj);
20617 export function Pong_free(this_obj: number): void {
20618 if(!isWasmInitialized) {
20619 throw new Error("initializeWasm() must be awaited first!");
20621 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
20622 // debug statements here
20624 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
20626 export function Pong_get_byteslen(this_ptr: number): number {
20627 if(!isWasmInitialized) {
20628 throw new Error("initializeWasm() must be awaited first!");
20630 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
20631 return nativeResponseValue;
20633 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
20635 export function Pong_set_byteslen(this_ptr: number, val: number): void {
20636 if(!isWasmInitialized) {
20637 throw new Error("initializeWasm() must be awaited first!");
20639 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
20640 // debug statements here
20642 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
20644 export function Pong_new(byteslen_arg: number): number {
20645 if(!isWasmInitialized) {
20646 throw new Error("initializeWasm() must be awaited first!");
20648 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
20649 return nativeResponseValue;
20651 // uintptr_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
20653 export function Pong_clone_ptr(arg: number): number {
20654 if(!isWasmInitialized) {
20655 throw new Error("initializeWasm() must be awaited first!");
20657 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
20658 return nativeResponseValue;
20660 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
20662 export function Pong_clone(orig: number): number {
20663 if(!isWasmInitialized) {
20664 throw new Error("initializeWasm() must be awaited first!");
20666 const nativeResponseValue = wasm.TS_Pong_clone(orig);
20667 return nativeResponseValue;
20669 // void OpenChannel_free(struct LDKOpenChannel this_obj);
20671 export function OpenChannel_free(this_obj: number): void {
20672 if(!isWasmInitialized) {
20673 throw new Error("initializeWasm() must be awaited first!");
20675 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
20676 // debug statements here
20678 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
20680 export function OpenChannel_get_chain_hash(this_ptr: number): number {
20681 if(!isWasmInitialized) {
20682 throw new Error("initializeWasm() must be awaited first!");
20684 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
20685 return nativeResponseValue;
20687 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20689 export function OpenChannel_set_chain_hash(this_ptr: number, val: number): void {
20690 if(!isWasmInitialized) {
20691 throw new Error("initializeWasm() must be awaited first!");
20693 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
20694 // debug statements here
20696 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
20698 export function OpenChannel_get_temporary_channel_id(this_ptr: number): number {
20699 if(!isWasmInitialized) {
20700 throw new Error("initializeWasm() must be awaited first!");
20702 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
20703 return nativeResponseValue;
20705 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20707 export function OpenChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
20708 if(!isWasmInitialized) {
20709 throw new Error("initializeWasm() must be awaited first!");
20711 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
20712 // debug statements here
20714 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20716 export function OpenChannel_get_funding_satoshis(this_ptr: number): bigint {
20717 if(!isWasmInitialized) {
20718 throw new Error("initializeWasm() must be awaited first!");
20720 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
20721 return nativeResponseValue;
20723 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20725 export function OpenChannel_set_funding_satoshis(this_ptr: number, val: bigint): void {
20726 if(!isWasmInitialized) {
20727 throw new Error("initializeWasm() must be awaited first!");
20729 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
20730 // debug statements here
20732 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20734 export function OpenChannel_get_push_msat(this_ptr: number): bigint {
20735 if(!isWasmInitialized) {
20736 throw new Error("initializeWasm() must be awaited first!");
20738 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
20739 return nativeResponseValue;
20741 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20743 export function OpenChannel_set_push_msat(this_ptr: number, val: bigint): void {
20744 if(!isWasmInitialized) {
20745 throw new Error("initializeWasm() must be awaited first!");
20747 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
20748 // debug statements here
20750 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20752 export function OpenChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
20753 if(!isWasmInitialized) {
20754 throw new Error("initializeWasm() must be awaited first!");
20756 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
20757 return nativeResponseValue;
20759 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20761 export function OpenChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
20762 if(!isWasmInitialized) {
20763 throw new Error("initializeWasm() must be awaited first!");
20765 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
20766 // debug statements here
20768 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20770 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
20771 if(!isWasmInitialized) {
20772 throw new Error("initializeWasm() must be awaited first!");
20774 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
20775 return nativeResponseValue;
20777 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20779 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
20780 if(!isWasmInitialized) {
20781 throw new Error("initializeWasm() must be awaited first!");
20783 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
20784 // debug statements here
20786 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20788 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
20789 if(!isWasmInitialized) {
20790 throw new Error("initializeWasm() must be awaited first!");
20792 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
20793 return nativeResponseValue;
20795 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20797 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
20798 if(!isWasmInitialized) {
20799 throw new Error("initializeWasm() must be awaited first!");
20801 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
20802 // debug statements here
20804 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20806 export function OpenChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
20807 if(!isWasmInitialized) {
20808 throw new Error("initializeWasm() must be awaited first!");
20810 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
20811 return nativeResponseValue;
20813 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20815 export function OpenChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
20816 if(!isWasmInitialized) {
20817 throw new Error("initializeWasm() must be awaited first!");
20819 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
20820 // debug statements here
20822 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20824 export function OpenChannel_get_feerate_per_kw(this_ptr: number): number {
20825 if(!isWasmInitialized) {
20826 throw new Error("initializeWasm() must be awaited first!");
20828 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
20829 return nativeResponseValue;
20831 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
20833 export function OpenChannel_set_feerate_per_kw(this_ptr: number, val: number): void {
20834 if(!isWasmInitialized) {
20835 throw new Error("initializeWasm() must be awaited first!");
20837 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
20838 // debug statements here
20840 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20842 export function OpenChannel_get_to_self_delay(this_ptr: number): number {
20843 if(!isWasmInitialized) {
20844 throw new Error("initializeWasm() must be awaited first!");
20846 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
20847 return nativeResponseValue;
20849 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
20851 export function OpenChannel_set_to_self_delay(this_ptr: number, val: number): void {
20852 if(!isWasmInitialized) {
20853 throw new Error("initializeWasm() must be awaited first!");
20855 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
20856 // debug statements here
20858 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20860 export function OpenChannel_get_max_accepted_htlcs(this_ptr: number): number {
20861 if(!isWasmInitialized) {
20862 throw new Error("initializeWasm() must be awaited first!");
20864 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
20865 return nativeResponseValue;
20867 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
20869 export function OpenChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
20870 if(!isWasmInitialized) {
20871 throw new Error("initializeWasm() must be awaited first!");
20873 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
20874 // debug statements here
20876 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20878 export function OpenChannel_get_funding_pubkey(this_ptr: number): number {
20879 if(!isWasmInitialized) {
20880 throw new Error("initializeWasm() must be awaited first!");
20882 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
20883 return nativeResponseValue;
20885 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20887 export function OpenChannel_set_funding_pubkey(this_ptr: number, val: number): void {
20888 if(!isWasmInitialized) {
20889 throw new Error("initializeWasm() must be awaited first!");
20891 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
20892 // debug statements here
20894 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20896 export function OpenChannel_get_revocation_basepoint(this_ptr: number): number {
20897 if(!isWasmInitialized) {
20898 throw new Error("initializeWasm() must be awaited first!");
20900 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
20901 return nativeResponseValue;
20903 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20905 export function OpenChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
20906 if(!isWasmInitialized) {
20907 throw new Error("initializeWasm() must be awaited first!");
20909 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
20910 // debug statements here
20912 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20914 export function OpenChannel_get_payment_point(this_ptr: number): number {
20915 if(!isWasmInitialized) {
20916 throw new Error("initializeWasm() must be awaited first!");
20918 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
20919 return nativeResponseValue;
20921 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20923 export function OpenChannel_set_payment_point(this_ptr: number, val: number): void {
20924 if(!isWasmInitialized) {
20925 throw new Error("initializeWasm() must be awaited first!");
20927 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
20928 // debug statements here
20930 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20932 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: number): number {
20933 if(!isWasmInitialized) {
20934 throw new Error("initializeWasm() must be awaited first!");
20936 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
20937 return nativeResponseValue;
20939 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20941 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
20942 if(!isWasmInitialized) {
20943 throw new Error("initializeWasm() must be awaited first!");
20945 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
20946 // debug statements here
20948 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20950 export function OpenChannel_get_htlc_basepoint(this_ptr: number): number {
20951 if(!isWasmInitialized) {
20952 throw new Error("initializeWasm() must be awaited first!");
20954 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
20955 return nativeResponseValue;
20957 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20959 export function OpenChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
20960 if(!isWasmInitialized) {
20961 throw new Error("initializeWasm() must be awaited first!");
20963 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
20964 // debug statements here
20966 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20968 export function OpenChannel_get_first_per_commitment_point(this_ptr: number): number {
20969 if(!isWasmInitialized) {
20970 throw new Error("initializeWasm() must be awaited first!");
20972 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
20973 return nativeResponseValue;
20975 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20977 export function OpenChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
20978 if(!isWasmInitialized) {
20979 throw new Error("initializeWasm() must be awaited first!");
20981 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
20982 // debug statements here
20984 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20986 export function OpenChannel_get_channel_flags(this_ptr: number): number {
20987 if(!isWasmInitialized) {
20988 throw new Error("initializeWasm() must be awaited first!");
20990 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
20991 return nativeResponseValue;
20993 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
20995 export function OpenChannel_set_channel_flags(this_ptr: number, val: number): void {
20996 if(!isWasmInitialized) {
20997 throw new Error("initializeWasm() must be awaited first!");
20999 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
21000 // debug statements here
21002 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21004 export function OpenChannel_get_channel_type(this_ptr: number): number {
21005 if(!isWasmInitialized) {
21006 throw new Error("initializeWasm() must be awaited first!");
21008 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
21009 return nativeResponseValue;
21011 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
21013 export function OpenChannel_set_channel_type(this_ptr: number, val: number): void {
21014 if(!isWasmInitialized) {
21015 throw new Error("initializeWasm() must be awaited first!");
21017 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
21018 // debug statements here
21020 // uintptr_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
21022 export function OpenChannel_clone_ptr(arg: number): number {
21023 if(!isWasmInitialized) {
21024 throw new Error("initializeWasm() must be awaited first!");
21026 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
21027 return nativeResponseValue;
21029 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
21031 export function OpenChannel_clone(orig: number): number {
21032 if(!isWasmInitialized) {
21033 throw new Error("initializeWasm() must be awaited first!");
21035 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
21036 return nativeResponseValue;
21038 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
21040 export function AcceptChannel_free(this_obj: number): void {
21041 if(!isWasmInitialized) {
21042 throw new Error("initializeWasm() must be awaited first!");
21044 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
21045 // debug statements here
21047 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
21049 export function AcceptChannel_get_temporary_channel_id(this_ptr: number): number {
21050 if(!isWasmInitialized) {
21051 throw new Error("initializeWasm() must be awaited first!");
21053 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
21054 return nativeResponseValue;
21056 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21058 export function AcceptChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
21059 if(!isWasmInitialized) {
21060 throw new Error("initializeWasm() must be awaited first!");
21062 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
21063 // debug statements here
21065 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21067 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
21068 if(!isWasmInitialized) {
21069 throw new Error("initializeWasm() must be awaited first!");
21071 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
21072 return nativeResponseValue;
21074 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21076 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
21077 if(!isWasmInitialized) {
21078 throw new Error("initializeWasm() must be awaited first!");
21080 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
21081 // debug statements here
21083 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21085 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
21086 if(!isWasmInitialized) {
21087 throw new Error("initializeWasm() must be awaited first!");
21089 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
21090 return nativeResponseValue;
21092 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21094 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
21095 if(!isWasmInitialized) {
21096 throw new Error("initializeWasm() must be awaited first!");
21098 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
21099 // debug statements here
21101 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21103 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
21104 if(!isWasmInitialized) {
21105 throw new Error("initializeWasm() must be awaited first!");
21107 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
21108 return nativeResponseValue;
21110 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21112 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
21113 if(!isWasmInitialized) {
21114 throw new Error("initializeWasm() must be awaited first!");
21116 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
21117 // debug statements here
21119 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21121 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
21122 if(!isWasmInitialized) {
21123 throw new Error("initializeWasm() must be awaited first!");
21125 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
21126 return nativeResponseValue;
21128 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21130 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
21131 if(!isWasmInitialized) {
21132 throw new Error("initializeWasm() must be awaited first!");
21134 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
21135 // debug statements here
21137 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21139 export function AcceptChannel_get_minimum_depth(this_ptr: number): number {
21140 if(!isWasmInitialized) {
21141 throw new Error("initializeWasm() must be awaited first!");
21143 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
21144 return nativeResponseValue;
21146 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
21148 export function AcceptChannel_set_minimum_depth(this_ptr: number, val: number): void {
21149 if(!isWasmInitialized) {
21150 throw new Error("initializeWasm() must be awaited first!");
21152 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
21153 // debug statements here
21155 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21157 export function AcceptChannel_get_to_self_delay(this_ptr: number): number {
21158 if(!isWasmInitialized) {
21159 throw new Error("initializeWasm() must be awaited first!");
21161 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
21162 return nativeResponseValue;
21164 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
21166 export function AcceptChannel_set_to_self_delay(this_ptr: number, val: number): void {
21167 if(!isWasmInitialized) {
21168 throw new Error("initializeWasm() must be awaited first!");
21170 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
21171 // debug statements here
21173 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21175 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: number): number {
21176 if(!isWasmInitialized) {
21177 throw new Error("initializeWasm() must be awaited first!");
21179 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
21180 return nativeResponseValue;
21182 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
21184 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
21185 if(!isWasmInitialized) {
21186 throw new Error("initializeWasm() must be awaited first!");
21188 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
21189 // debug statements here
21191 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21193 export function AcceptChannel_get_funding_pubkey(this_ptr: number): number {
21194 if(!isWasmInitialized) {
21195 throw new Error("initializeWasm() must be awaited first!");
21197 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
21198 return nativeResponseValue;
21200 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21202 export function AcceptChannel_set_funding_pubkey(this_ptr: number, val: number): void {
21203 if(!isWasmInitialized) {
21204 throw new Error("initializeWasm() must be awaited first!");
21206 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
21207 // debug statements here
21209 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21211 export function AcceptChannel_get_revocation_basepoint(this_ptr: number): number {
21212 if(!isWasmInitialized) {
21213 throw new Error("initializeWasm() must be awaited first!");
21215 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
21216 return nativeResponseValue;
21218 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21220 export function AcceptChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
21221 if(!isWasmInitialized) {
21222 throw new Error("initializeWasm() must be awaited first!");
21224 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
21225 // debug statements here
21227 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21229 export function AcceptChannel_get_payment_point(this_ptr: number): number {
21230 if(!isWasmInitialized) {
21231 throw new Error("initializeWasm() must be awaited first!");
21233 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
21234 return nativeResponseValue;
21236 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21238 export function AcceptChannel_set_payment_point(this_ptr: number, val: number): void {
21239 if(!isWasmInitialized) {
21240 throw new Error("initializeWasm() must be awaited first!");
21242 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
21243 // debug statements here
21245 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21247 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: number): number {
21248 if(!isWasmInitialized) {
21249 throw new Error("initializeWasm() must be awaited first!");
21251 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
21252 return nativeResponseValue;
21254 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21256 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
21257 if(!isWasmInitialized) {
21258 throw new Error("initializeWasm() must be awaited first!");
21260 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
21261 // debug statements here
21263 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21265 export function AcceptChannel_get_htlc_basepoint(this_ptr: number): number {
21266 if(!isWasmInitialized) {
21267 throw new Error("initializeWasm() must be awaited first!");
21269 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
21270 return nativeResponseValue;
21272 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21274 export function AcceptChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
21275 if(!isWasmInitialized) {
21276 throw new Error("initializeWasm() must be awaited first!");
21278 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
21279 // debug statements here
21281 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21283 export function AcceptChannel_get_first_per_commitment_point(this_ptr: number): number {
21284 if(!isWasmInitialized) {
21285 throw new Error("initializeWasm() must be awaited first!");
21287 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
21288 return nativeResponseValue;
21290 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21292 export function AcceptChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
21293 if(!isWasmInitialized) {
21294 throw new Error("initializeWasm() must be awaited first!");
21296 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
21297 // debug statements here
21299 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21301 export function AcceptChannel_get_channel_type(this_ptr: number): number {
21302 if(!isWasmInitialized) {
21303 throw new Error("initializeWasm() must be awaited first!");
21305 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
21306 return nativeResponseValue;
21308 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
21310 export function AcceptChannel_set_channel_type(this_ptr: number, val: number): void {
21311 if(!isWasmInitialized) {
21312 throw new Error("initializeWasm() must be awaited first!");
21314 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
21315 // debug statements here
21317 // uintptr_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
21319 export function AcceptChannel_clone_ptr(arg: number): number {
21320 if(!isWasmInitialized) {
21321 throw new Error("initializeWasm() must be awaited first!");
21323 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
21324 return nativeResponseValue;
21326 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
21328 export function AcceptChannel_clone(orig: number): number {
21329 if(!isWasmInitialized) {
21330 throw new Error("initializeWasm() must be awaited first!");
21332 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
21333 return nativeResponseValue;
21335 // void FundingCreated_free(struct LDKFundingCreated this_obj);
21337 export function FundingCreated_free(this_obj: number): void {
21338 if(!isWasmInitialized) {
21339 throw new Error("initializeWasm() must be awaited first!");
21341 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
21342 // debug statements here
21344 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21346 export function FundingCreated_get_temporary_channel_id(this_ptr: number): number {
21347 if(!isWasmInitialized) {
21348 throw new Error("initializeWasm() must be awaited first!");
21350 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
21351 return nativeResponseValue;
21353 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21355 export function FundingCreated_set_temporary_channel_id(this_ptr: number, val: number): void {
21356 if(!isWasmInitialized) {
21357 throw new Error("initializeWasm() must be awaited first!");
21359 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
21360 // debug statements here
21362 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21364 export function FundingCreated_get_funding_txid(this_ptr: number): number {
21365 if(!isWasmInitialized) {
21366 throw new Error("initializeWasm() must be awaited first!");
21368 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
21369 return nativeResponseValue;
21371 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21373 export function FundingCreated_set_funding_txid(this_ptr: number, val: number): void {
21374 if(!isWasmInitialized) {
21375 throw new Error("initializeWasm() must be awaited first!");
21377 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
21378 // debug statements here
21380 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21382 export function FundingCreated_get_funding_output_index(this_ptr: number): number {
21383 if(!isWasmInitialized) {
21384 throw new Error("initializeWasm() must be awaited first!");
21386 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
21387 return nativeResponseValue;
21389 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
21391 export function FundingCreated_set_funding_output_index(this_ptr: number, val: number): void {
21392 if(!isWasmInitialized) {
21393 throw new Error("initializeWasm() must be awaited first!");
21395 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
21396 // debug statements here
21398 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21400 export function FundingCreated_get_signature(this_ptr: number): number {
21401 if(!isWasmInitialized) {
21402 throw new Error("initializeWasm() must be awaited first!");
21404 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
21405 return nativeResponseValue;
21407 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
21409 export function FundingCreated_set_signature(this_ptr: number, val: number): void {
21410 if(!isWasmInitialized) {
21411 throw new Error("initializeWasm() must be awaited first!");
21413 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
21414 // debug statements here
21416 // 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);
21418 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): number {
21419 if(!isWasmInitialized) {
21420 throw new Error("initializeWasm() must be awaited first!");
21422 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
21423 return nativeResponseValue;
21425 // uintptr_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
21427 export function FundingCreated_clone_ptr(arg: number): number {
21428 if(!isWasmInitialized) {
21429 throw new Error("initializeWasm() must be awaited first!");
21431 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
21432 return nativeResponseValue;
21434 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
21436 export function FundingCreated_clone(orig: number): number {
21437 if(!isWasmInitialized) {
21438 throw new Error("initializeWasm() must be awaited first!");
21440 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
21441 return nativeResponseValue;
21443 // void FundingSigned_free(struct LDKFundingSigned this_obj);
21445 export function FundingSigned_free(this_obj: number): void {
21446 if(!isWasmInitialized) {
21447 throw new Error("initializeWasm() must be awaited first!");
21449 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
21450 // debug statements here
21452 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
21454 export function FundingSigned_get_channel_id(this_ptr: number): number {
21455 if(!isWasmInitialized) {
21456 throw new Error("initializeWasm() must be awaited first!");
21458 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
21459 return nativeResponseValue;
21461 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21463 export function FundingSigned_set_channel_id(this_ptr: number, val: number): void {
21464 if(!isWasmInitialized) {
21465 throw new Error("initializeWasm() must be awaited first!");
21467 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
21468 // debug statements here
21470 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
21472 export function FundingSigned_get_signature(this_ptr: number): number {
21473 if(!isWasmInitialized) {
21474 throw new Error("initializeWasm() must be awaited first!");
21476 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
21477 return nativeResponseValue;
21479 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21481 export function FundingSigned_set_signature(this_ptr: number, val: number): void {
21482 if(!isWasmInitialized) {
21483 throw new Error("initializeWasm() must be awaited first!");
21485 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
21486 // debug statements here
21488 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
21490 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): number {
21491 if(!isWasmInitialized) {
21492 throw new Error("initializeWasm() must be awaited first!");
21494 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
21495 return nativeResponseValue;
21497 // uintptr_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
21499 export function FundingSigned_clone_ptr(arg: number): number {
21500 if(!isWasmInitialized) {
21501 throw new Error("initializeWasm() must be awaited first!");
21503 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
21504 return nativeResponseValue;
21506 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
21508 export function FundingSigned_clone(orig: number): number {
21509 if(!isWasmInitialized) {
21510 throw new Error("initializeWasm() must be awaited first!");
21512 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
21513 return nativeResponseValue;
21515 // void ChannelReady_free(struct LDKChannelReady this_obj);
21517 export function ChannelReady_free(this_obj: number): void {
21518 if(!isWasmInitialized) {
21519 throw new Error("initializeWasm() must be awaited first!");
21521 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
21522 // debug statements here
21524 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
21526 export function ChannelReady_get_channel_id(this_ptr: number): number {
21527 if(!isWasmInitialized) {
21528 throw new Error("initializeWasm() must be awaited first!");
21530 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
21531 return nativeResponseValue;
21533 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21535 export function ChannelReady_set_channel_id(this_ptr: number, val: number): void {
21536 if(!isWasmInitialized) {
21537 throw new Error("initializeWasm() must be awaited first!");
21539 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
21540 // debug statements here
21542 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
21544 export function ChannelReady_get_next_per_commitment_point(this_ptr: number): number {
21545 if(!isWasmInitialized) {
21546 throw new Error("initializeWasm() must be awaited first!");
21548 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
21549 return nativeResponseValue;
21551 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21553 export function ChannelReady_set_next_per_commitment_point(this_ptr: number, val: number): void {
21554 if(!isWasmInitialized) {
21555 throw new Error("initializeWasm() must be awaited first!");
21557 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
21558 // debug statements here
21560 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
21562 export function ChannelReady_get_short_channel_id_alias(this_ptr: number): number {
21563 if(!isWasmInitialized) {
21564 throw new Error("initializeWasm() must be awaited first!");
21566 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
21567 return nativeResponseValue;
21569 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21571 export function ChannelReady_set_short_channel_id_alias(this_ptr: number, val: number): void {
21572 if(!isWasmInitialized) {
21573 throw new Error("initializeWasm() must be awaited first!");
21575 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
21576 // debug statements here
21578 // 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);
21580 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: number): number {
21581 if(!isWasmInitialized) {
21582 throw new Error("initializeWasm() must be awaited first!");
21584 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
21585 return nativeResponseValue;
21587 // uintptr_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
21589 export function ChannelReady_clone_ptr(arg: number): number {
21590 if(!isWasmInitialized) {
21591 throw new Error("initializeWasm() must be awaited first!");
21593 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
21594 return nativeResponseValue;
21596 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
21598 export function ChannelReady_clone(orig: number): number {
21599 if(!isWasmInitialized) {
21600 throw new Error("initializeWasm() must be awaited first!");
21602 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
21603 return nativeResponseValue;
21605 // void Shutdown_free(struct LDKShutdown this_obj);
21607 export function Shutdown_free(this_obj: number): void {
21608 if(!isWasmInitialized) {
21609 throw new Error("initializeWasm() must be awaited first!");
21611 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
21612 // debug statements here
21614 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
21616 export function Shutdown_get_channel_id(this_ptr: number): number {
21617 if(!isWasmInitialized) {
21618 throw new Error("initializeWasm() must be awaited first!");
21620 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
21621 return nativeResponseValue;
21623 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21625 export function Shutdown_set_channel_id(this_ptr: number, val: number): void {
21626 if(!isWasmInitialized) {
21627 throw new Error("initializeWasm() must be awaited first!");
21629 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
21630 // debug statements here
21632 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
21634 export function Shutdown_get_scriptpubkey(this_ptr: number): number {
21635 if(!isWasmInitialized) {
21636 throw new Error("initializeWasm() must be awaited first!");
21638 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
21639 return nativeResponseValue;
21641 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
21643 export function Shutdown_set_scriptpubkey(this_ptr: number, val: number): void {
21644 if(!isWasmInitialized) {
21645 throw new Error("initializeWasm() must be awaited first!");
21647 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
21648 // debug statements here
21650 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
21652 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): number {
21653 if(!isWasmInitialized) {
21654 throw new Error("initializeWasm() must be awaited first!");
21656 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
21657 return nativeResponseValue;
21659 // uintptr_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
21661 export function Shutdown_clone_ptr(arg: number): number {
21662 if(!isWasmInitialized) {
21663 throw new Error("initializeWasm() must be awaited first!");
21665 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
21666 return nativeResponseValue;
21668 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
21670 export function Shutdown_clone(orig: number): number {
21671 if(!isWasmInitialized) {
21672 throw new Error("initializeWasm() must be awaited first!");
21674 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
21675 return nativeResponseValue;
21677 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
21679 export function ClosingSignedFeeRange_free(this_obj: number): void {
21680 if(!isWasmInitialized) {
21681 throw new Error("initializeWasm() must be awaited first!");
21683 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
21684 // debug statements here
21686 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
21688 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: number): bigint {
21689 if(!isWasmInitialized) {
21690 throw new Error("initializeWasm() must be awaited first!");
21692 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
21693 return nativeResponseValue;
21695 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
21697 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: number, val: bigint): void {
21698 if(!isWasmInitialized) {
21699 throw new Error("initializeWasm() must be awaited first!");
21701 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
21702 // debug statements here
21704 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
21706 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: number): bigint {
21707 if(!isWasmInitialized) {
21708 throw new Error("initializeWasm() must be awaited first!");
21710 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
21711 return nativeResponseValue;
21713 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
21715 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: number, val: bigint): void {
21716 if(!isWasmInitialized) {
21717 throw new Error("initializeWasm() must be awaited first!");
21719 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
21720 // debug statements here
21722 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
21724 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): number {
21725 if(!isWasmInitialized) {
21726 throw new Error("initializeWasm() must be awaited first!");
21728 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
21729 return nativeResponseValue;
21731 // uintptr_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
21733 export function ClosingSignedFeeRange_clone_ptr(arg: number): number {
21734 if(!isWasmInitialized) {
21735 throw new Error("initializeWasm() must be awaited first!");
21737 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
21738 return nativeResponseValue;
21740 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
21742 export function ClosingSignedFeeRange_clone(orig: number): number {
21743 if(!isWasmInitialized) {
21744 throw new Error("initializeWasm() must be awaited first!");
21746 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
21747 return nativeResponseValue;
21749 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
21751 export function ClosingSigned_free(this_obj: number): void {
21752 if(!isWasmInitialized) {
21753 throw new Error("initializeWasm() must be awaited first!");
21755 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
21756 // debug statements here
21758 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
21760 export function ClosingSigned_get_channel_id(this_ptr: number): number {
21761 if(!isWasmInitialized) {
21762 throw new Error("initializeWasm() must be awaited first!");
21764 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
21765 return nativeResponseValue;
21767 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21769 export function ClosingSigned_set_channel_id(this_ptr: number, val: number): void {
21770 if(!isWasmInitialized) {
21771 throw new Error("initializeWasm() must be awaited first!");
21773 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
21774 // debug statements here
21776 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
21778 export function ClosingSigned_get_fee_satoshis(this_ptr: number): bigint {
21779 if(!isWasmInitialized) {
21780 throw new Error("initializeWasm() must be awaited first!");
21782 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
21783 return nativeResponseValue;
21785 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
21787 export function ClosingSigned_set_fee_satoshis(this_ptr: number, val: bigint): void {
21788 if(!isWasmInitialized) {
21789 throw new Error("initializeWasm() must be awaited first!");
21791 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
21792 // debug statements here
21794 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
21796 export function ClosingSigned_get_signature(this_ptr: number): number {
21797 if(!isWasmInitialized) {
21798 throw new Error("initializeWasm() must be awaited first!");
21800 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
21801 return nativeResponseValue;
21803 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21805 export function ClosingSigned_set_signature(this_ptr: number, val: number): void {
21806 if(!isWasmInitialized) {
21807 throw new Error("initializeWasm() must be awaited first!");
21809 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
21810 // debug statements here
21812 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
21814 export function ClosingSigned_get_fee_range(this_ptr: number): number {
21815 if(!isWasmInitialized) {
21816 throw new Error("initializeWasm() must be awaited first!");
21818 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
21819 return nativeResponseValue;
21821 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
21823 export function ClosingSigned_set_fee_range(this_ptr: number, val: number): void {
21824 if(!isWasmInitialized) {
21825 throw new Error("initializeWasm() must be awaited first!");
21827 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
21828 // debug statements here
21830 // 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);
21832 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: number): number {
21833 if(!isWasmInitialized) {
21834 throw new Error("initializeWasm() must be awaited first!");
21836 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
21837 return nativeResponseValue;
21839 // uintptr_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
21841 export function ClosingSigned_clone_ptr(arg: number): number {
21842 if(!isWasmInitialized) {
21843 throw new Error("initializeWasm() must be awaited first!");
21845 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
21846 return nativeResponseValue;
21848 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
21850 export function ClosingSigned_clone(orig: number): number {
21851 if(!isWasmInitialized) {
21852 throw new Error("initializeWasm() must be awaited first!");
21854 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
21855 return nativeResponseValue;
21857 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
21859 export function UpdateAddHTLC_free(this_obj: number): void {
21860 if(!isWasmInitialized) {
21861 throw new Error("initializeWasm() must be awaited first!");
21863 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
21864 // debug statements here
21866 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
21868 export function UpdateAddHTLC_get_channel_id(this_ptr: number): number {
21869 if(!isWasmInitialized) {
21870 throw new Error("initializeWasm() must be awaited first!");
21872 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
21873 return nativeResponseValue;
21875 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21877 export function UpdateAddHTLC_set_channel_id(this_ptr: number, val: number): void {
21878 if(!isWasmInitialized) {
21879 throw new Error("initializeWasm() must be awaited first!");
21881 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
21882 // debug statements here
21884 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21886 export function UpdateAddHTLC_get_htlc_id(this_ptr: number): bigint {
21887 if(!isWasmInitialized) {
21888 throw new Error("initializeWasm() must be awaited first!");
21890 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
21891 return nativeResponseValue;
21893 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
21895 export function UpdateAddHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21896 if(!isWasmInitialized) {
21897 throw new Error("initializeWasm() must be awaited first!");
21899 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
21900 // debug statements here
21902 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21904 export function UpdateAddHTLC_get_amount_msat(this_ptr: number): bigint {
21905 if(!isWasmInitialized) {
21906 throw new Error("initializeWasm() must be awaited first!");
21908 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
21909 return nativeResponseValue;
21911 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
21913 export function UpdateAddHTLC_set_amount_msat(this_ptr: number, val: bigint): void {
21914 if(!isWasmInitialized) {
21915 throw new Error("initializeWasm() must be awaited first!");
21917 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
21918 // debug statements here
21920 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
21922 export function UpdateAddHTLC_get_payment_hash(this_ptr: number): number {
21923 if(!isWasmInitialized) {
21924 throw new Error("initializeWasm() must be awaited first!");
21926 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
21927 return nativeResponseValue;
21929 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21931 export function UpdateAddHTLC_set_payment_hash(this_ptr: number, val: number): void {
21932 if(!isWasmInitialized) {
21933 throw new Error("initializeWasm() must be awaited first!");
21935 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
21936 // debug statements here
21938 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21940 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: number): number {
21941 if(!isWasmInitialized) {
21942 throw new Error("initializeWasm() must be awaited first!");
21944 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
21945 return nativeResponseValue;
21947 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
21949 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: number, val: number): void {
21950 if(!isWasmInitialized) {
21951 throw new Error("initializeWasm() must be awaited first!");
21953 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
21954 // debug statements here
21956 // uintptr_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
21958 export function UpdateAddHTLC_clone_ptr(arg: number): number {
21959 if(!isWasmInitialized) {
21960 throw new Error("initializeWasm() must be awaited first!");
21962 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
21963 return nativeResponseValue;
21965 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
21967 export function UpdateAddHTLC_clone(orig: number): number {
21968 if(!isWasmInitialized) {
21969 throw new Error("initializeWasm() must be awaited first!");
21971 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
21972 return nativeResponseValue;
21974 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
21976 export function UpdateFulfillHTLC_free(this_obj: number): void {
21977 if(!isWasmInitialized) {
21978 throw new Error("initializeWasm() must be awaited first!");
21980 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
21981 // debug statements here
21983 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
21985 export function UpdateFulfillHTLC_get_channel_id(this_ptr: number): number {
21986 if(!isWasmInitialized) {
21987 throw new Error("initializeWasm() must be awaited first!");
21989 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
21990 return nativeResponseValue;
21992 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21994 export function UpdateFulfillHTLC_set_channel_id(this_ptr: number, val: number): void {
21995 if(!isWasmInitialized) {
21996 throw new Error("initializeWasm() must be awaited first!");
21998 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
21999 // debug statements here
22001 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
22003 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: number): bigint {
22004 if(!isWasmInitialized) {
22005 throw new Error("initializeWasm() must be awaited first!");
22007 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
22008 return nativeResponseValue;
22010 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
22012 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22013 if(!isWasmInitialized) {
22014 throw new Error("initializeWasm() must be awaited first!");
22016 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
22017 // debug statements here
22019 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
22021 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: number): number {
22022 if(!isWasmInitialized) {
22023 throw new Error("initializeWasm() must be awaited first!");
22025 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
22026 return nativeResponseValue;
22028 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22030 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: number, val: number): void {
22031 if(!isWasmInitialized) {
22032 throw new Error("initializeWasm() must be awaited first!");
22034 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
22035 // debug statements here
22037 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
22039 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): number {
22040 if(!isWasmInitialized) {
22041 throw new Error("initializeWasm() must be awaited first!");
22043 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
22044 return nativeResponseValue;
22046 // uintptr_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
22048 export function UpdateFulfillHTLC_clone_ptr(arg: number): number {
22049 if(!isWasmInitialized) {
22050 throw new Error("initializeWasm() must be awaited first!");
22052 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
22053 return nativeResponseValue;
22055 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
22057 export function UpdateFulfillHTLC_clone(orig: number): number {
22058 if(!isWasmInitialized) {
22059 throw new Error("initializeWasm() must be awaited first!");
22061 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
22062 return nativeResponseValue;
22064 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
22066 export function UpdateFailHTLC_free(this_obj: number): void {
22067 if(!isWasmInitialized) {
22068 throw new Error("initializeWasm() must be awaited first!");
22070 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
22071 // debug statements here
22073 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
22075 export function UpdateFailHTLC_get_channel_id(this_ptr: number): number {
22076 if(!isWasmInitialized) {
22077 throw new Error("initializeWasm() must be awaited first!");
22079 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
22080 return nativeResponseValue;
22082 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22084 export function UpdateFailHTLC_set_channel_id(this_ptr: number, val: number): void {
22085 if(!isWasmInitialized) {
22086 throw new Error("initializeWasm() must be awaited first!");
22088 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
22089 // debug statements here
22091 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
22093 export function UpdateFailHTLC_get_htlc_id(this_ptr: number): bigint {
22094 if(!isWasmInitialized) {
22095 throw new Error("initializeWasm() must be awaited first!");
22097 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
22098 return nativeResponseValue;
22100 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
22102 export function UpdateFailHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22103 if(!isWasmInitialized) {
22104 throw new Error("initializeWasm() must be awaited first!");
22106 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
22107 // debug statements here
22109 // uintptr_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
22111 export function UpdateFailHTLC_clone_ptr(arg: number): number {
22112 if(!isWasmInitialized) {
22113 throw new Error("initializeWasm() must be awaited first!");
22115 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
22116 return nativeResponseValue;
22118 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
22120 export function UpdateFailHTLC_clone(orig: number): number {
22121 if(!isWasmInitialized) {
22122 throw new Error("initializeWasm() must be awaited first!");
22124 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
22125 return nativeResponseValue;
22127 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
22129 export function UpdateFailMalformedHTLC_free(this_obj: number): void {
22130 if(!isWasmInitialized) {
22131 throw new Error("initializeWasm() must be awaited first!");
22133 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
22134 // debug statements here
22136 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
22138 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: number): number {
22139 if(!isWasmInitialized) {
22140 throw new Error("initializeWasm() must be awaited first!");
22142 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
22143 return nativeResponseValue;
22145 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22147 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: number, val: number): void {
22148 if(!isWasmInitialized) {
22149 throw new Error("initializeWasm() must be awaited first!");
22151 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
22152 // debug statements here
22154 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
22156 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: number): bigint {
22157 if(!isWasmInitialized) {
22158 throw new Error("initializeWasm() must be awaited first!");
22160 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
22161 return nativeResponseValue;
22163 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
22165 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22166 if(!isWasmInitialized) {
22167 throw new Error("initializeWasm() must be awaited first!");
22169 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
22170 // debug statements here
22172 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
22174 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: number): number {
22175 if(!isWasmInitialized) {
22176 throw new Error("initializeWasm() must be awaited first!");
22178 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
22179 return nativeResponseValue;
22181 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
22183 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: number, val: number): void {
22184 if(!isWasmInitialized) {
22185 throw new Error("initializeWasm() must be awaited first!");
22187 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
22188 // debug statements here
22190 // uintptr_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
22192 export function UpdateFailMalformedHTLC_clone_ptr(arg: number): number {
22193 if(!isWasmInitialized) {
22194 throw new Error("initializeWasm() must be awaited first!");
22196 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
22197 return nativeResponseValue;
22199 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
22201 export function UpdateFailMalformedHTLC_clone(orig: number): number {
22202 if(!isWasmInitialized) {
22203 throw new Error("initializeWasm() must be awaited first!");
22205 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
22206 return nativeResponseValue;
22208 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
22210 export function CommitmentSigned_free(this_obj: number): void {
22211 if(!isWasmInitialized) {
22212 throw new Error("initializeWasm() must be awaited first!");
22214 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
22215 // debug statements here
22217 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
22219 export function CommitmentSigned_get_channel_id(this_ptr: number): number {
22220 if(!isWasmInitialized) {
22221 throw new Error("initializeWasm() must be awaited first!");
22223 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
22224 return nativeResponseValue;
22226 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22228 export function CommitmentSigned_set_channel_id(this_ptr: number, val: number): void {
22229 if(!isWasmInitialized) {
22230 throw new Error("initializeWasm() must be awaited first!");
22232 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
22233 // debug statements here
22235 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
22237 export function CommitmentSigned_get_signature(this_ptr: number): number {
22238 if(!isWasmInitialized) {
22239 throw new Error("initializeWasm() must be awaited first!");
22241 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
22242 return nativeResponseValue;
22244 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
22246 export function CommitmentSigned_set_signature(this_ptr: number, val: number): void {
22247 if(!isWasmInitialized) {
22248 throw new Error("initializeWasm() must be awaited first!");
22250 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
22251 // debug statements here
22253 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
22255 export function CommitmentSigned_set_htlc_signatures(this_ptr: number, val: number): void {
22256 if(!isWasmInitialized) {
22257 throw new Error("initializeWasm() must be awaited first!");
22259 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
22260 // debug statements here
22262 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
22264 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): number {
22265 if(!isWasmInitialized) {
22266 throw new Error("initializeWasm() must be awaited first!");
22268 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
22269 return nativeResponseValue;
22271 // uintptr_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
22273 export function CommitmentSigned_clone_ptr(arg: number): number {
22274 if(!isWasmInitialized) {
22275 throw new Error("initializeWasm() must be awaited first!");
22277 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
22278 return nativeResponseValue;
22280 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
22282 export function CommitmentSigned_clone(orig: number): number {
22283 if(!isWasmInitialized) {
22284 throw new Error("initializeWasm() must be awaited first!");
22286 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
22287 return nativeResponseValue;
22289 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
22291 export function RevokeAndACK_free(this_obj: number): void {
22292 if(!isWasmInitialized) {
22293 throw new Error("initializeWasm() must be awaited first!");
22295 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
22296 // debug statements here
22298 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22300 export function RevokeAndACK_get_channel_id(this_ptr: number): number {
22301 if(!isWasmInitialized) {
22302 throw new Error("initializeWasm() must be awaited first!");
22304 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
22305 return nativeResponseValue;
22307 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22309 export function RevokeAndACK_set_channel_id(this_ptr: number, val: number): void {
22310 if(!isWasmInitialized) {
22311 throw new Error("initializeWasm() must be awaited first!");
22313 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
22314 // debug statements here
22316 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22318 export function RevokeAndACK_get_per_commitment_secret(this_ptr: number): number {
22319 if(!isWasmInitialized) {
22320 throw new Error("initializeWasm() must be awaited first!");
22322 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
22323 return nativeResponseValue;
22325 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22327 export function RevokeAndACK_set_per_commitment_secret(this_ptr: number, val: number): void {
22328 if(!isWasmInitialized) {
22329 throw new Error("initializeWasm() must be awaited first!");
22331 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
22332 // debug statements here
22334 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
22336 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: number): number {
22337 if(!isWasmInitialized) {
22338 throw new Error("initializeWasm() must be awaited first!");
22340 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
22341 return nativeResponseValue;
22343 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22345 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: number, val: number): void {
22346 if(!isWasmInitialized) {
22347 throw new Error("initializeWasm() must be awaited first!");
22349 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
22350 // debug statements here
22352 // 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);
22354 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): number {
22355 if(!isWasmInitialized) {
22356 throw new Error("initializeWasm() must be awaited first!");
22358 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
22359 return nativeResponseValue;
22361 // uintptr_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
22363 export function RevokeAndACK_clone_ptr(arg: number): number {
22364 if(!isWasmInitialized) {
22365 throw new Error("initializeWasm() must be awaited first!");
22367 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
22368 return nativeResponseValue;
22370 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
22372 export function RevokeAndACK_clone(orig: number): number {
22373 if(!isWasmInitialized) {
22374 throw new Error("initializeWasm() must be awaited first!");
22376 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
22377 return nativeResponseValue;
22379 // void UpdateFee_free(struct LDKUpdateFee this_obj);
22381 export function UpdateFee_free(this_obj: number): void {
22382 if(!isWasmInitialized) {
22383 throw new Error("initializeWasm() must be awaited first!");
22385 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
22386 // debug statements here
22388 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
22390 export function UpdateFee_get_channel_id(this_ptr: number): number {
22391 if(!isWasmInitialized) {
22392 throw new Error("initializeWasm() must be awaited first!");
22394 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
22395 return nativeResponseValue;
22397 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22399 export function UpdateFee_set_channel_id(this_ptr: number, val: number): void {
22400 if(!isWasmInitialized) {
22401 throw new Error("initializeWasm() must be awaited first!");
22403 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
22404 // debug statements here
22406 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
22408 export function UpdateFee_get_feerate_per_kw(this_ptr: number): number {
22409 if(!isWasmInitialized) {
22410 throw new Error("initializeWasm() must be awaited first!");
22412 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
22413 return nativeResponseValue;
22415 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
22417 export function UpdateFee_set_feerate_per_kw(this_ptr: number, val: number): void {
22418 if(!isWasmInitialized) {
22419 throw new Error("initializeWasm() must be awaited first!");
22421 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
22422 // debug statements here
22424 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
22426 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): number {
22427 if(!isWasmInitialized) {
22428 throw new Error("initializeWasm() must be awaited first!");
22430 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
22431 return nativeResponseValue;
22433 // uintptr_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
22435 export function UpdateFee_clone_ptr(arg: number): number {
22436 if(!isWasmInitialized) {
22437 throw new Error("initializeWasm() must be awaited first!");
22439 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
22440 return nativeResponseValue;
22442 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
22444 export function UpdateFee_clone(orig: number): number {
22445 if(!isWasmInitialized) {
22446 throw new Error("initializeWasm() must be awaited first!");
22448 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
22449 return nativeResponseValue;
22451 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
22453 export function DataLossProtect_free(this_obj: number): void {
22454 if(!isWasmInitialized) {
22455 throw new Error("initializeWasm() must be awaited first!");
22457 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
22458 // debug statements here
22460 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
22462 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: number): number {
22463 if(!isWasmInitialized) {
22464 throw new Error("initializeWasm() must be awaited first!");
22466 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
22467 return nativeResponseValue;
22469 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22471 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: number, val: number): void {
22472 if(!isWasmInitialized) {
22473 throw new Error("initializeWasm() must be awaited first!");
22475 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
22476 // debug statements here
22478 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
22480 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: number): number {
22481 if(!isWasmInitialized) {
22482 throw new Error("initializeWasm() must be awaited first!");
22484 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
22485 return nativeResponseValue;
22487 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22489 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: number, val: number): void {
22490 if(!isWasmInitialized) {
22491 throw new Error("initializeWasm() must be awaited first!");
22493 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
22494 // debug statements here
22496 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
22498 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): number {
22499 if(!isWasmInitialized) {
22500 throw new Error("initializeWasm() must be awaited first!");
22502 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
22503 return nativeResponseValue;
22505 // uintptr_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
22507 export function DataLossProtect_clone_ptr(arg: number): number {
22508 if(!isWasmInitialized) {
22509 throw new Error("initializeWasm() must be awaited first!");
22511 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
22512 return nativeResponseValue;
22514 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
22516 export function DataLossProtect_clone(orig: number): number {
22517 if(!isWasmInitialized) {
22518 throw new Error("initializeWasm() must be awaited first!");
22520 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
22521 return nativeResponseValue;
22523 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
22525 export function ChannelReestablish_free(this_obj: number): void {
22526 if(!isWasmInitialized) {
22527 throw new Error("initializeWasm() must be awaited first!");
22529 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
22530 // debug statements here
22532 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
22534 export function ChannelReestablish_get_channel_id(this_ptr: number): number {
22535 if(!isWasmInitialized) {
22536 throw new Error("initializeWasm() must be awaited first!");
22538 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
22539 return nativeResponseValue;
22541 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22543 export function ChannelReestablish_set_channel_id(this_ptr: number, val: number): void {
22544 if(!isWasmInitialized) {
22545 throw new Error("initializeWasm() must be awaited first!");
22547 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
22548 // debug statements here
22550 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
22552 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: number): bigint {
22553 if(!isWasmInitialized) {
22554 throw new Error("initializeWasm() must be awaited first!");
22556 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
22557 return nativeResponseValue;
22559 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
22561 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: number, val: bigint): void {
22562 if(!isWasmInitialized) {
22563 throw new Error("initializeWasm() must be awaited first!");
22565 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
22566 // debug statements here
22568 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
22570 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: number): bigint {
22571 if(!isWasmInitialized) {
22572 throw new Error("initializeWasm() must be awaited first!");
22574 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
22575 return nativeResponseValue;
22577 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
22579 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: number, val: bigint): void {
22580 if(!isWasmInitialized) {
22581 throw new Error("initializeWasm() must be awaited first!");
22583 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
22584 // debug statements here
22586 // uintptr_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
22588 export function ChannelReestablish_clone_ptr(arg: number): number {
22589 if(!isWasmInitialized) {
22590 throw new Error("initializeWasm() must be awaited first!");
22592 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
22593 return nativeResponseValue;
22595 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
22597 export function ChannelReestablish_clone(orig: number): number {
22598 if(!isWasmInitialized) {
22599 throw new Error("initializeWasm() must be awaited first!");
22601 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
22602 return nativeResponseValue;
22604 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
22606 export function AnnouncementSignatures_free(this_obj: number): void {
22607 if(!isWasmInitialized) {
22608 throw new Error("initializeWasm() must be awaited first!");
22610 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
22611 // debug statements here
22613 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
22615 export function AnnouncementSignatures_get_channel_id(this_ptr: number): number {
22616 if(!isWasmInitialized) {
22617 throw new Error("initializeWasm() must be awaited first!");
22619 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
22620 return nativeResponseValue;
22622 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22624 export function AnnouncementSignatures_set_channel_id(this_ptr: number, val: number): void {
22625 if(!isWasmInitialized) {
22626 throw new Error("initializeWasm() must be awaited first!");
22628 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
22629 // debug statements here
22631 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
22633 export function AnnouncementSignatures_get_short_channel_id(this_ptr: number): bigint {
22634 if(!isWasmInitialized) {
22635 throw new Error("initializeWasm() must be awaited first!");
22637 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
22638 return nativeResponseValue;
22640 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
22642 export function AnnouncementSignatures_set_short_channel_id(this_ptr: number, val: bigint): void {
22643 if(!isWasmInitialized) {
22644 throw new Error("initializeWasm() must be awaited first!");
22646 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
22647 // debug statements here
22649 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
22651 export function AnnouncementSignatures_get_node_signature(this_ptr: number): number {
22652 if(!isWasmInitialized) {
22653 throw new Error("initializeWasm() must be awaited first!");
22655 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
22656 return nativeResponseValue;
22658 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
22660 export function AnnouncementSignatures_set_node_signature(this_ptr: number, val: number): void {
22661 if(!isWasmInitialized) {
22662 throw new Error("initializeWasm() must be awaited first!");
22664 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
22665 // debug statements here
22667 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
22669 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: number): number {
22670 if(!isWasmInitialized) {
22671 throw new Error("initializeWasm() must be awaited first!");
22673 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
22674 return nativeResponseValue;
22676 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
22678 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: number, val: number): void {
22679 if(!isWasmInitialized) {
22680 throw new Error("initializeWasm() must be awaited first!");
22682 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
22683 // debug statements here
22685 // 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);
22687 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): number {
22688 if(!isWasmInitialized) {
22689 throw new Error("initializeWasm() must be awaited first!");
22691 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
22692 return nativeResponseValue;
22694 // uintptr_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
22696 export function AnnouncementSignatures_clone_ptr(arg: number): number {
22697 if(!isWasmInitialized) {
22698 throw new Error("initializeWasm() must be awaited first!");
22700 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
22701 return nativeResponseValue;
22703 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
22705 export function AnnouncementSignatures_clone(orig: number): number {
22706 if(!isWasmInitialized) {
22707 throw new Error("initializeWasm() must be awaited first!");
22709 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
22710 return nativeResponseValue;
22712 // void NetAddress_free(struct LDKNetAddress this_ptr);
22714 export function NetAddress_free(this_ptr: number): void {
22715 if(!isWasmInitialized) {
22716 throw new Error("initializeWasm() must be awaited first!");
22718 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
22719 // debug statements here
22721 // uintptr_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
22723 export function NetAddress_clone_ptr(arg: number): number {
22724 if(!isWasmInitialized) {
22725 throw new Error("initializeWasm() must be awaited first!");
22727 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
22728 return nativeResponseValue;
22730 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
22732 export function NetAddress_clone(orig: number): number {
22733 if(!isWasmInitialized) {
22734 throw new Error("initializeWasm() must be awaited first!");
22736 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
22737 return nativeResponseValue;
22739 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
22741 export function NetAddress_ipv4(addr: number, port: number): number {
22742 if(!isWasmInitialized) {
22743 throw new Error("initializeWasm() must be awaited first!");
22745 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
22746 return nativeResponseValue;
22748 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
22750 export function NetAddress_ipv6(addr: number, port: number): number {
22751 if(!isWasmInitialized) {
22752 throw new Error("initializeWasm() must be awaited first!");
22754 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
22755 return nativeResponseValue;
22757 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
22759 export function NetAddress_onion_v2(a: number): number {
22760 if(!isWasmInitialized) {
22761 throw new Error("initializeWasm() must be awaited first!");
22763 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
22764 return nativeResponseValue;
22766 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
22768 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): number {
22769 if(!isWasmInitialized) {
22770 throw new Error("initializeWasm() must be awaited first!");
22772 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
22773 return nativeResponseValue;
22775 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
22777 export function NetAddress_write(obj: number): number {
22778 if(!isWasmInitialized) {
22779 throw new Error("initializeWasm() must be awaited first!");
22781 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
22782 return nativeResponseValue;
22784 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
22786 export function NetAddress_read(ser: number): number {
22787 if(!isWasmInitialized) {
22788 throw new Error("initializeWasm() must be awaited first!");
22790 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
22791 return nativeResponseValue;
22793 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
22795 export function UnsignedNodeAnnouncement_free(this_obj: number): void {
22796 if(!isWasmInitialized) {
22797 throw new Error("initializeWasm() must be awaited first!");
22799 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
22800 // debug statements here
22802 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
22804 export function UnsignedNodeAnnouncement_get_features(this_ptr: number): number {
22805 if(!isWasmInitialized) {
22806 throw new Error("initializeWasm() must be awaited first!");
22808 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
22809 return nativeResponseValue;
22811 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
22813 export function UnsignedNodeAnnouncement_set_features(this_ptr: number, val: number): void {
22814 if(!isWasmInitialized) {
22815 throw new Error("initializeWasm() must be awaited first!");
22817 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
22818 // debug statements here
22820 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
22822 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: number): number {
22823 if(!isWasmInitialized) {
22824 throw new Error("initializeWasm() must be awaited first!");
22826 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
22827 return nativeResponseValue;
22829 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
22831 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: number, val: number): void {
22832 if(!isWasmInitialized) {
22833 throw new Error("initializeWasm() must be awaited first!");
22835 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
22836 // debug statements here
22838 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
22840 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: number): number {
22841 if(!isWasmInitialized) {
22842 throw new Error("initializeWasm() must be awaited first!");
22844 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
22845 return nativeResponseValue;
22847 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22849 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: number, val: number): void {
22850 if(!isWasmInitialized) {
22851 throw new Error("initializeWasm() must be awaited first!");
22853 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
22854 // debug statements here
22856 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
22858 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: number): number {
22859 if(!isWasmInitialized) {
22860 throw new Error("initializeWasm() must be awaited first!");
22862 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
22863 return nativeResponseValue;
22865 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
22867 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: number, val: number): void {
22868 if(!isWasmInitialized) {
22869 throw new Error("initializeWasm() must be awaited first!");
22871 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
22872 // debug statements here
22874 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
22876 export function UnsignedNodeAnnouncement_get_alias(this_ptr: number): number {
22877 if(!isWasmInitialized) {
22878 throw new Error("initializeWasm() must be awaited first!");
22880 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
22881 return nativeResponseValue;
22883 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22885 export function UnsignedNodeAnnouncement_set_alias(this_ptr: number, val: number): void {
22886 if(!isWasmInitialized) {
22887 throw new Error("initializeWasm() must be awaited first!");
22889 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
22890 // debug statements here
22892 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
22894 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: number, val: number): void {
22895 if(!isWasmInitialized) {
22896 throw new Error("initializeWasm() must be awaited first!");
22898 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
22899 // debug statements here
22901 // uintptr_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
22903 export function UnsignedNodeAnnouncement_clone_ptr(arg: number): number {
22904 if(!isWasmInitialized) {
22905 throw new Error("initializeWasm() must be awaited first!");
22907 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
22908 return nativeResponseValue;
22910 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
22912 export function UnsignedNodeAnnouncement_clone(orig: number): number {
22913 if(!isWasmInitialized) {
22914 throw new Error("initializeWasm() must be awaited first!");
22916 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
22917 return nativeResponseValue;
22919 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
22921 export function NodeAnnouncement_free(this_obj: number): void {
22922 if(!isWasmInitialized) {
22923 throw new Error("initializeWasm() must be awaited first!");
22925 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
22926 // debug statements here
22928 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
22930 export function NodeAnnouncement_get_signature(this_ptr: number): number {
22931 if(!isWasmInitialized) {
22932 throw new Error("initializeWasm() must be awaited first!");
22934 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
22935 return nativeResponseValue;
22937 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22939 export function NodeAnnouncement_set_signature(this_ptr: number, val: number): void {
22940 if(!isWasmInitialized) {
22941 throw new Error("initializeWasm() must be awaited first!");
22943 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
22944 // debug statements here
22946 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
22948 export function NodeAnnouncement_get_contents(this_ptr: number): number {
22949 if(!isWasmInitialized) {
22950 throw new Error("initializeWasm() must be awaited first!");
22952 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
22953 return nativeResponseValue;
22955 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
22957 export function NodeAnnouncement_set_contents(this_ptr: number, val: number): void {
22958 if(!isWasmInitialized) {
22959 throw new Error("initializeWasm() must be awaited first!");
22961 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
22962 // debug statements here
22964 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
22966 export function NodeAnnouncement_new(signature_arg: number, contents_arg: number): number {
22967 if(!isWasmInitialized) {
22968 throw new Error("initializeWasm() must be awaited first!");
22970 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
22971 return nativeResponseValue;
22973 // uintptr_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
22975 export function NodeAnnouncement_clone_ptr(arg: number): number {
22976 if(!isWasmInitialized) {
22977 throw new Error("initializeWasm() must be awaited first!");
22979 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
22980 return nativeResponseValue;
22982 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
22984 export function NodeAnnouncement_clone(orig: number): number {
22985 if(!isWasmInitialized) {
22986 throw new Error("initializeWasm() must be awaited first!");
22988 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
22989 return nativeResponseValue;
22991 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
22993 export function UnsignedChannelAnnouncement_free(this_obj: number): void {
22994 if(!isWasmInitialized) {
22995 throw new Error("initializeWasm() must be awaited first!");
22997 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
22998 // debug statements here
23000 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23002 export function UnsignedChannelAnnouncement_get_features(this_ptr: number): number {
23003 if(!isWasmInitialized) {
23004 throw new Error("initializeWasm() must be awaited first!");
23006 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
23007 return nativeResponseValue;
23009 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
23011 export function UnsignedChannelAnnouncement_set_features(this_ptr: number, val: number): void {
23012 if(!isWasmInitialized) {
23013 throw new Error("initializeWasm() must be awaited first!");
23015 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
23016 // debug statements here
23018 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
23020 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: number): number {
23021 if(!isWasmInitialized) {
23022 throw new Error("initializeWasm() must be awaited first!");
23024 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
23025 return nativeResponseValue;
23027 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23029 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: number, val: number): void {
23030 if(!isWasmInitialized) {
23031 throw new Error("initializeWasm() must be awaited first!");
23033 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
23034 // debug statements here
23036 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23038 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: number): bigint {
23039 if(!isWasmInitialized) {
23040 throw new Error("initializeWasm() must be awaited first!");
23042 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
23043 return nativeResponseValue;
23045 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
23047 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: number, val: bigint): void {
23048 if(!isWasmInitialized) {
23049 throw new Error("initializeWasm() must be awaited first!");
23051 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
23052 // debug statements here
23054 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23056 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: number): number {
23057 if(!isWasmInitialized) {
23058 throw new Error("initializeWasm() must be awaited first!");
23060 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
23061 return nativeResponseValue;
23063 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23065 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: number, val: number): void {
23066 if(!isWasmInitialized) {
23067 throw new Error("initializeWasm() must be awaited first!");
23069 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
23070 // debug statements here
23072 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23074 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: number): number {
23075 if(!isWasmInitialized) {
23076 throw new Error("initializeWasm() must be awaited first!");
23078 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
23079 return nativeResponseValue;
23081 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23083 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: number, val: number): void {
23084 if(!isWasmInitialized) {
23085 throw new Error("initializeWasm() must be awaited first!");
23087 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
23088 // debug statements here
23090 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23092 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: number): number {
23093 if(!isWasmInitialized) {
23094 throw new Error("initializeWasm() must be awaited first!");
23096 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
23097 return nativeResponseValue;
23099 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23101 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: number, val: number): void {
23102 if(!isWasmInitialized) {
23103 throw new Error("initializeWasm() must be awaited first!");
23105 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
23106 // debug statements here
23108 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23110 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: number): number {
23111 if(!isWasmInitialized) {
23112 throw new Error("initializeWasm() must be awaited first!");
23114 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
23115 return nativeResponseValue;
23117 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23119 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: number, val: number): void {
23120 if(!isWasmInitialized) {
23121 throw new Error("initializeWasm() must be awaited first!");
23123 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
23124 // debug statements here
23126 // uintptr_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
23128 export function UnsignedChannelAnnouncement_clone_ptr(arg: number): number {
23129 if(!isWasmInitialized) {
23130 throw new Error("initializeWasm() must be awaited first!");
23132 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
23133 return nativeResponseValue;
23135 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
23137 export function UnsignedChannelAnnouncement_clone(orig: number): number {
23138 if(!isWasmInitialized) {
23139 throw new Error("initializeWasm() must be awaited first!");
23141 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
23142 return nativeResponseValue;
23144 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
23146 export function ChannelAnnouncement_free(this_obj: number): void {
23147 if(!isWasmInitialized) {
23148 throw new Error("initializeWasm() must be awaited first!");
23150 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
23151 // debug statements here
23153 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23155 export function ChannelAnnouncement_get_node_signature_1(this_ptr: number): number {
23156 if(!isWasmInitialized) {
23157 throw new Error("initializeWasm() must be awaited first!");
23159 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
23160 return nativeResponseValue;
23162 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23164 export function ChannelAnnouncement_set_node_signature_1(this_ptr: number, val: number): void {
23165 if(!isWasmInitialized) {
23166 throw new Error("initializeWasm() must be awaited first!");
23168 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
23169 // debug statements here
23171 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23173 export function ChannelAnnouncement_get_node_signature_2(this_ptr: number): number {
23174 if(!isWasmInitialized) {
23175 throw new Error("initializeWasm() must be awaited first!");
23177 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
23178 return nativeResponseValue;
23180 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23182 export function ChannelAnnouncement_set_node_signature_2(this_ptr: number, val: number): void {
23183 if(!isWasmInitialized) {
23184 throw new Error("initializeWasm() must be awaited first!");
23186 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
23187 // debug statements here
23189 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23191 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: number): number {
23192 if(!isWasmInitialized) {
23193 throw new Error("initializeWasm() must be awaited first!");
23195 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
23196 return nativeResponseValue;
23198 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23200 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: number, val: number): void {
23201 if(!isWasmInitialized) {
23202 throw new Error("initializeWasm() must be awaited first!");
23204 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
23205 // debug statements here
23207 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23209 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: number): number {
23210 if(!isWasmInitialized) {
23211 throw new Error("initializeWasm() must be awaited first!");
23213 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
23214 return nativeResponseValue;
23216 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23218 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: number, val: number): void {
23219 if(!isWasmInitialized) {
23220 throw new Error("initializeWasm() must be awaited first!");
23222 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
23223 // debug statements here
23225 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23227 export function ChannelAnnouncement_get_contents(this_ptr: number): number {
23228 if(!isWasmInitialized) {
23229 throw new Error("initializeWasm() must be awaited first!");
23231 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
23232 return nativeResponseValue;
23234 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
23236 export function ChannelAnnouncement_set_contents(this_ptr: number, val: number): void {
23237 if(!isWasmInitialized) {
23238 throw new Error("initializeWasm() must be awaited first!");
23240 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
23241 // debug statements here
23243 // 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);
23245 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 {
23246 if(!isWasmInitialized) {
23247 throw new Error("initializeWasm() must be awaited first!");
23249 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
23250 return nativeResponseValue;
23252 // uintptr_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
23254 export function ChannelAnnouncement_clone_ptr(arg: number): number {
23255 if(!isWasmInitialized) {
23256 throw new Error("initializeWasm() must be awaited first!");
23258 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
23259 return nativeResponseValue;
23261 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
23263 export function ChannelAnnouncement_clone(orig: number): number {
23264 if(!isWasmInitialized) {
23265 throw new Error("initializeWasm() must be awaited first!");
23267 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
23268 return nativeResponseValue;
23270 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
23272 export function UnsignedChannelUpdate_free(this_obj: number): void {
23273 if(!isWasmInitialized) {
23274 throw new Error("initializeWasm() must be awaited first!");
23276 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
23277 // debug statements here
23279 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
23281 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: number): number {
23282 if(!isWasmInitialized) {
23283 throw new Error("initializeWasm() must be awaited first!");
23285 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
23286 return nativeResponseValue;
23288 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23290 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: number, val: number): void {
23291 if(!isWasmInitialized) {
23292 throw new Error("initializeWasm() must be awaited first!");
23294 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
23295 // debug statements here
23297 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23299 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: number): bigint {
23300 if(!isWasmInitialized) {
23301 throw new Error("initializeWasm() must be awaited first!");
23303 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
23304 return nativeResponseValue;
23306 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23308 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: number, val: bigint): void {
23309 if(!isWasmInitialized) {
23310 throw new Error("initializeWasm() must be awaited first!");
23312 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
23313 // debug statements here
23315 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23317 export function UnsignedChannelUpdate_get_timestamp(this_ptr: number): number {
23318 if(!isWasmInitialized) {
23319 throw new Error("initializeWasm() must be awaited first!");
23321 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
23322 return nativeResponseValue;
23324 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23326 export function UnsignedChannelUpdate_set_timestamp(this_ptr: number, val: number): void {
23327 if(!isWasmInitialized) {
23328 throw new Error("initializeWasm() must be awaited first!");
23330 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
23331 // debug statements here
23333 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23335 export function UnsignedChannelUpdate_get_flags(this_ptr: number): number {
23336 if(!isWasmInitialized) {
23337 throw new Error("initializeWasm() must be awaited first!");
23339 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
23340 return nativeResponseValue;
23342 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
23344 export function UnsignedChannelUpdate_set_flags(this_ptr: number, val: number): void {
23345 if(!isWasmInitialized) {
23346 throw new Error("initializeWasm() must be awaited first!");
23348 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
23349 // debug statements here
23351 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23353 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: number): number {
23354 if(!isWasmInitialized) {
23355 throw new Error("initializeWasm() must be awaited first!");
23357 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
23358 return nativeResponseValue;
23360 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
23362 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: number, val: number): void {
23363 if(!isWasmInitialized) {
23364 throw new Error("initializeWasm() must be awaited first!");
23366 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
23367 // debug statements here
23369 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23371 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: number): bigint {
23372 if(!isWasmInitialized) {
23373 throw new Error("initializeWasm() must be awaited first!");
23375 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
23376 return nativeResponseValue;
23378 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23380 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
23381 if(!isWasmInitialized) {
23382 throw new Error("initializeWasm() must be awaited first!");
23384 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
23385 // debug statements here
23387 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23389 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: number): number {
23390 if(!isWasmInitialized) {
23391 throw new Error("initializeWasm() must be awaited first!");
23393 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
23394 return nativeResponseValue;
23396 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23398 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: number, val: number): void {
23399 if(!isWasmInitialized) {
23400 throw new Error("initializeWasm() must be awaited first!");
23402 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
23403 // debug statements here
23405 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23407 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: number): number {
23408 if(!isWasmInitialized) {
23409 throw new Error("initializeWasm() must be awaited first!");
23411 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
23412 return nativeResponseValue;
23414 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23416 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: number, val: number): void {
23417 if(!isWasmInitialized) {
23418 throw new Error("initializeWasm() must be awaited first!");
23420 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
23421 // debug statements here
23423 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
23425 export function UnsignedChannelUpdate_set_excess_data(this_ptr: number, val: number): void {
23426 if(!isWasmInitialized) {
23427 throw new Error("initializeWasm() must be awaited first!");
23429 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
23430 // debug statements here
23432 // uintptr_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
23434 export function UnsignedChannelUpdate_clone_ptr(arg: number): number {
23435 if(!isWasmInitialized) {
23436 throw new Error("initializeWasm() must be awaited first!");
23438 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
23439 return nativeResponseValue;
23441 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
23443 export function UnsignedChannelUpdate_clone(orig: number): number {
23444 if(!isWasmInitialized) {
23445 throw new Error("initializeWasm() must be awaited first!");
23447 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
23448 return nativeResponseValue;
23450 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
23452 export function ChannelUpdate_free(this_obj: number): void {
23453 if(!isWasmInitialized) {
23454 throw new Error("initializeWasm() must be awaited first!");
23456 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
23457 // debug statements here
23459 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
23461 export function ChannelUpdate_get_signature(this_ptr: number): number {
23462 if(!isWasmInitialized) {
23463 throw new Error("initializeWasm() must be awaited first!");
23465 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
23466 return nativeResponseValue;
23468 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
23470 export function ChannelUpdate_set_signature(this_ptr: number, val: number): void {
23471 if(!isWasmInitialized) {
23472 throw new Error("initializeWasm() must be awaited first!");
23474 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
23475 // debug statements here
23477 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
23479 export function ChannelUpdate_get_contents(this_ptr: number): number {
23480 if(!isWasmInitialized) {
23481 throw new Error("initializeWasm() must be awaited first!");
23483 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
23484 return nativeResponseValue;
23486 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
23488 export function ChannelUpdate_set_contents(this_ptr: number, val: number): void {
23489 if(!isWasmInitialized) {
23490 throw new Error("initializeWasm() must be awaited first!");
23492 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
23493 // debug statements here
23495 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
23497 export function ChannelUpdate_new(signature_arg: number, contents_arg: number): number {
23498 if(!isWasmInitialized) {
23499 throw new Error("initializeWasm() must be awaited first!");
23501 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
23502 return nativeResponseValue;
23504 // uintptr_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
23506 export function ChannelUpdate_clone_ptr(arg: number): number {
23507 if(!isWasmInitialized) {
23508 throw new Error("initializeWasm() must be awaited first!");
23510 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
23511 return nativeResponseValue;
23513 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
23515 export function ChannelUpdate_clone(orig: number): number {
23516 if(!isWasmInitialized) {
23517 throw new Error("initializeWasm() must be awaited first!");
23519 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
23520 return nativeResponseValue;
23522 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
23524 export function QueryChannelRange_free(this_obj: number): void {
23525 if(!isWasmInitialized) {
23526 throw new Error("initializeWasm() must be awaited first!");
23528 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
23529 // debug statements here
23531 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
23533 export function QueryChannelRange_get_chain_hash(this_ptr: number): number {
23534 if(!isWasmInitialized) {
23535 throw new Error("initializeWasm() must be awaited first!");
23537 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
23538 return nativeResponseValue;
23540 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23542 export function QueryChannelRange_set_chain_hash(this_ptr: number, val: number): void {
23543 if(!isWasmInitialized) {
23544 throw new Error("initializeWasm() must be awaited first!");
23546 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
23547 // debug statements here
23549 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
23551 export function QueryChannelRange_get_first_blocknum(this_ptr: number): number {
23552 if(!isWasmInitialized) {
23553 throw new Error("initializeWasm() must be awaited first!");
23555 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
23556 return nativeResponseValue;
23558 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23560 export function QueryChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
23561 if(!isWasmInitialized) {
23562 throw new Error("initializeWasm() must be awaited first!");
23564 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
23565 // debug statements here
23567 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
23569 export function QueryChannelRange_get_number_of_blocks(this_ptr: number): number {
23570 if(!isWasmInitialized) {
23571 throw new Error("initializeWasm() must be awaited first!");
23573 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
23574 return nativeResponseValue;
23576 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23578 export function QueryChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
23579 if(!isWasmInitialized) {
23580 throw new Error("initializeWasm() must be awaited first!");
23582 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
23583 // debug statements here
23585 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
23587 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): number {
23588 if(!isWasmInitialized) {
23589 throw new Error("initializeWasm() must be awaited first!");
23591 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
23592 return nativeResponseValue;
23594 // uintptr_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
23596 export function QueryChannelRange_clone_ptr(arg: number): number {
23597 if(!isWasmInitialized) {
23598 throw new Error("initializeWasm() must be awaited first!");
23600 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
23601 return nativeResponseValue;
23603 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
23605 export function QueryChannelRange_clone(orig: number): number {
23606 if(!isWasmInitialized) {
23607 throw new Error("initializeWasm() must be awaited first!");
23609 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
23610 return nativeResponseValue;
23612 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
23614 export function ReplyChannelRange_free(this_obj: number): void {
23615 if(!isWasmInitialized) {
23616 throw new Error("initializeWasm() must be awaited first!");
23618 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
23619 // debug statements here
23621 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
23623 export function ReplyChannelRange_get_chain_hash(this_ptr: number): number {
23624 if(!isWasmInitialized) {
23625 throw new Error("initializeWasm() must be awaited first!");
23627 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
23628 return nativeResponseValue;
23630 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23632 export function ReplyChannelRange_set_chain_hash(this_ptr: number, val: number): void {
23633 if(!isWasmInitialized) {
23634 throw new Error("initializeWasm() must be awaited first!");
23636 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
23637 // debug statements here
23639 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
23641 export function ReplyChannelRange_get_first_blocknum(this_ptr: number): number {
23642 if(!isWasmInitialized) {
23643 throw new Error("initializeWasm() must be awaited first!");
23645 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
23646 return nativeResponseValue;
23648 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23650 export function ReplyChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
23651 if(!isWasmInitialized) {
23652 throw new Error("initializeWasm() must be awaited first!");
23654 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
23655 // debug statements here
23657 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
23659 export function ReplyChannelRange_get_number_of_blocks(this_ptr: number): number {
23660 if(!isWasmInitialized) {
23661 throw new Error("initializeWasm() must be awaited first!");
23663 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
23664 return nativeResponseValue;
23666 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23668 export function ReplyChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
23669 if(!isWasmInitialized) {
23670 throw new Error("initializeWasm() must be awaited first!");
23672 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
23673 // debug statements here
23675 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
23677 export function ReplyChannelRange_get_sync_complete(this_ptr: number): boolean {
23678 if(!isWasmInitialized) {
23679 throw new Error("initializeWasm() must be awaited first!");
23681 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
23682 return nativeResponseValue;
23684 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
23686 export function ReplyChannelRange_set_sync_complete(this_ptr: number, val: boolean): void {
23687 if(!isWasmInitialized) {
23688 throw new Error("initializeWasm() must be awaited first!");
23690 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
23691 // debug statements here
23693 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
23695 export function ReplyChannelRange_set_short_channel_ids(this_ptr: number, val: number): void {
23696 if(!isWasmInitialized) {
23697 throw new Error("initializeWasm() must be awaited first!");
23699 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
23700 // debug statements here
23702 // 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);
23704 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 {
23705 if(!isWasmInitialized) {
23706 throw new Error("initializeWasm() must be awaited first!");
23708 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
23709 return nativeResponseValue;
23711 // uintptr_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
23713 export function ReplyChannelRange_clone_ptr(arg: number): number {
23714 if(!isWasmInitialized) {
23715 throw new Error("initializeWasm() must be awaited first!");
23717 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
23718 return nativeResponseValue;
23720 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
23722 export function ReplyChannelRange_clone(orig: number): number {
23723 if(!isWasmInitialized) {
23724 throw new Error("initializeWasm() must be awaited first!");
23726 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
23727 return nativeResponseValue;
23729 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
23731 export function QueryShortChannelIds_free(this_obj: number): void {
23732 if(!isWasmInitialized) {
23733 throw new Error("initializeWasm() must be awaited first!");
23735 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
23736 // debug statements here
23738 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
23740 export function QueryShortChannelIds_get_chain_hash(this_ptr: number): number {
23741 if(!isWasmInitialized) {
23742 throw new Error("initializeWasm() must be awaited first!");
23744 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
23745 return nativeResponseValue;
23747 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23749 export function QueryShortChannelIds_set_chain_hash(this_ptr: number, val: number): void {
23750 if(!isWasmInitialized) {
23751 throw new Error("initializeWasm() must be awaited first!");
23753 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
23754 // debug statements here
23756 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
23758 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: number, val: number): void {
23759 if(!isWasmInitialized) {
23760 throw new Error("initializeWasm() must be awaited first!");
23762 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
23763 // debug statements here
23765 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
23767 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): number {
23768 if(!isWasmInitialized) {
23769 throw new Error("initializeWasm() must be awaited first!");
23771 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
23772 return nativeResponseValue;
23774 // uintptr_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
23776 export function QueryShortChannelIds_clone_ptr(arg: number): number {
23777 if(!isWasmInitialized) {
23778 throw new Error("initializeWasm() must be awaited first!");
23780 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
23781 return nativeResponseValue;
23783 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
23785 export function QueryShortChannelIds_clone(orig: number): number {
23786 if(!isWasmInitialized) {
23787 throw new Error("initializeWasm() must be awaited first!");
23789 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
23790 return nativeResponseValue;
23792 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
23794 export function ReplyShortChannelIdsEnd_free(this_obj: number): void {
23795 if(!isWasmInitialized) {
23796 throw new Error("initializeWasm() must be awaited first!");
23798 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
23799 // debug statements here
23801 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
23803 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: number): number {
23804 if(!isWasmInitialized) {
23805 throw new Error("initializeWasm() must be awaited first!");
23807 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
23808 return nativeResponseValue;
23810 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23812 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: number, val: number): void {
23813 if(!isWasmInitialized) {
23814 throw new Error("initializeWasm() must be awaited first!");
23816 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
23817 // debug statements here
23819 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
23821 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: number): boolean {
23822 if(!isWasmInitialized) {
23823 throw new Error("initializeWasm() must be awaited first!");
23825 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
23826 return nativeResponseValue;
23828 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
23830 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: number, val: boolean): void {
23831 if(!isWasmInitialized) {
23832 throw new Error("initializeWasm() must be awaited first!");
23834 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
23835 // debug statements here
23837 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
23839 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): number {
23840 if(!isWasmInitialized) {
23841 throw new Error("initializeWasm() must be awaited first!");
23843 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
23844 return nativeResponseValue;
23846 // uintptr_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
23848 export function ReplyShortChannelIdsEnd_clone_ptr(arg: number): number {
23849 if(!isWasmInitialized) {
23850 throw new Error("initializeWasm() must be awaited first!");
23852 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
23853 return nativeResponseValue;
23855 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
23857 export function ReplyShortChannelIdsEnd_clone(orig: number): number {
23858 if(!isWasmInitialized) {
23859 throw new Error("initializeWasm() must be awaited first!");
23861 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
23862 return nativeResponseValue;
23864 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
23866 export function GossipTimestampFilter_free(this_obj: number): void {
23867 if(!isWasmInitialized) {
23868 throw new Error("initializeWasm() must be awaited first!");
23870 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
23871 // debug statements here
23873 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
23875 export function GossipTimestampFilter_get_chain_hash(this_ptr: number): number {
23876 if(!isWasmInitialized) {
23877 throw new Error("initializeWasm() must be awaited first!");
23879 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
23880 return nativeResponseValue;
23882 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23884 export function GossipTimestampFilter_set_chain_hash(this_ptr: number, val: number): void {
23885 if(!isWasmInitialized) {
23886 throw new Error("initializeWasm() must be awaited first!");
23888 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
23889 // debug statements here
23891 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
23893 export function GossipTimestampFilter_get_first_timestamp(this_ptr: number): number {
23894 if(!isWasmInitialized) {
23895 throw new Error("initializeWasm() must be awaited first!");
23897 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
23898 return nativeResponseValue;
23900 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
23902 export function GossipTimestampFilter_set_first_timestamp(this_ptr: number, val: number): void {
23903 if(!isWasmInitialized) {
23904 throw new Error("initializeWasm() must be awaited first!");
23906 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
23907 // debug statements here
23909 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
23911 export function GossipTimestampFilter_get_timestamp_range(this_ptr: number): number {
23912 if(!isWasmInitialized) {
23913 throw new Error("initializeWasm() must be awaited first!");
23915 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
23916 return nativeResponseValue;
23918 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
23920 export function GossipTimestampFilter_set_timestamp_range(this_ptr: number, val: number): void {
23921 if(!isWasmInitialized) {
23922 throw new Error("initializeWasm() must be awaited first!");
23924 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
23925 // debug statements here
23927 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
23929 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): number {
23930 if(!isWasmInitialized) {
23931 throw new Error("initializeWasm() must be awaited first!");
23933 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
23934 return nativeResponseValue;
23936 // uintptr_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
23938 export function GossipTimestampFilter_clone_ptr(arg: number): number {
23939 if(!isWasmInitialized) {
23940 throw new Error("initializeWasm() must be awaited first!");
23942 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
23943 return nativeResponseValue;
23945 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
23947 export function GossipTimestampFilter_clone(orig: number): number {
23948 if(!isWasmInitialized) {
23949 throw new Error("initializeWasm() must be awaited first!");
23951 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
23952 return nativeResponseValue;
23954 // void ErrorAction_free(struct LDKErrorAction this_ptr);
23956 export function ErrorAction_free(this_ptr: number): void {
23957 if(!isWasmInitialized) {
23958 throw new Error("initializeWasm() must be awaited first!");
23960 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
23961 // debug statements here
23963 // uintptr_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
23965 export function ErrorAction_clone_ptr(arg: number): number {
23966 if(!isWasmInitialized) {
23967 throw new Error("initializeWasm() must be awaited first!");
23969 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
23970 return nativeResponseValue;
23972 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
23974 export function ErrorAction_clone(orig: number): number {
23975 if(!isWasmInitialized) {
23976 throw new Error("initializeWasm() must be awaited first!");
23978 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
23979 return nativeResponseValue;
23981 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
23983 export function ErrorAction_disconnect_peer(msg: number): number {
23984 if(!isWasmInitialized) {
23985 throw new Error("initializeWasm() must be awaited first!");
23987 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
23988 return nativeResponseValue;
23990 // struct LDKErrorAction ErrorAction_ignore_error(void);
23992 export function ErrorAction_ignore_error(): number {
23993 if(!isWasmInitialized) {
23994 throw new Error("initializeWasm() must be awaited first!");
23996 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
23997 return nativeResponseValue;
23999 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
24001 export function ErrorAction_ignore_and_log(a: Level): number {
24002 if(!isWasmInitialized) {
24003 throw new Error("initializeWasm() must be awaited first!");
24005 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
24006 return nativeResponseValue;
24008 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
24010 export function ErrorAction_ignore_duplicate_gossip(): number {
24011 if(!isWasmInitialized) {
24012 throw new Error("initializeWasm() must be awaited first!");
24014 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
24015 return nativeResponseValue;
24017 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
24019 export function ErrorAction_send_error_message(msg: number): number {
24020 if(!isWasmInitialized) {
24021 throw new Error("initializeWasm() must be awaited first!");
24023 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
24024 return nativeResponseValue;
24026 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
24028 export function ErrorAction_send_warning_message(msg: number, log_level: Level): number {
24029 if(!isWasmInitialized) {
24030 throw new Error("initializeWasm() must be awaited first!");
24032 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
24033 return nativeResponseValue;
24035 // void LightningError_free(struct LDKLightningError this_obj);
24037 export function LightningError_free(this_obj: number): void {
24038 if(!isWasmInitialized) {
24039 throw new Error("initializeWasm() must be awaited first!");
24041 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
24042 // debug statements here
24044 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
24046 export function LightningError_get_err(this_ptr: number): number {
24047 if(!isWasmInitialized) {
24048 throw new Error("initializeWasm() must be awaited first!");
24050 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
24051 return nativeResponseValue;
24053 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
24055 export function LightningError_set_err(this_ptr: number, val: number): void {
24056 if(!isWasmInitialized) {
24057 throw new Error("initializeWasm() must be awaited first!");
24059 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
24060 // debug statements here
24062 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
24064 export function LightningError_get_action(this_ptr: number): number {
24065 if(!isWasmInitialized) {
24066 throw new Error("initializeWasm() must be awaited first!");
24068 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
24069 return nativeResponseValue;
24071 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
24073 export function LightningError_set_action(this_ptr: number, val: number): void {
24074 if(!isWasmInitialized) {
24075 throw new Error("initializeWasm() must be awaited first!");
24077 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
24078 // debug statements here
24080 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
24082 export function LightningError_new(err_arg: number, action_arg: number): number {
24083 if(!isWasmInitialized) {
24084 throw new Error("initializeWasm() must be awaited first!");
24086 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
24087 return nativeResponseValue;
24089 // uintptr_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
24091 export function LightningError_clone_ptr(arg: number): number {
24092 if(!isWasmInitialized) {
24093 throw new Error("initializeWasm() must be awaited first!");
24095 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
24096 return nativeResponseValue;
24098 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
24100 export function LightningError_clone(orig: number): number {
24101 if(!isWasmInitialized) {
24102 throw new Error("initializeWasm() must be awaited first!");
24104 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
24105 return nativeResponseValue;
24107 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
24109 export function CommitmentUpdate_free(this_obj: number): void {
24110 if(!isWasmInitialized) {
24111 throw new Error("initializeWasm() must be awaited first!");
24113 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
24114 // debug statements here
24116 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24118 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: number): number {
24119 if(!isWasmInitialized) {
24120 throw new Error("initializeWasm() must be awaited first!");
24122 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
24123 return nativeResponseValue;
24125 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
24127 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: number, val: number): void {
24128 if(!isWasmInitialized) {
24129 throw new Error("initializeWasm() must be awaited first!");
24131 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
24132 // debug statements here
24134 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24136 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: number): number {
24137 if(!isWasmInitialized) {
24138 throw new Error("initializeWasm() must be awaited first!");
24140 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
24141 return nativeResponseValue;
24143 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
24145 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: number, val: number): void {
24146 if(!isWasmInitialized) {
24147 throw new Error("initializeWasm() must be awaited first!");
24149 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
24150 // debug statements here
24152 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24154 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: number): number {
24155 if(!isWasmInitialized) {
24156 throw new Error("initializeWasm() must be awaited first!");
24158 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
24159 return nativeResponseValue;
24161 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
24163 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: number, val: number): void {
24164 if(!isWasmInitialized) {
24165 throw new Error("initializeWasm() must be awaited first!");
24167 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
24168 // debug statements here
24170 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24172 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: number): number {
24173 if(!isWasmInitialized) {
24174 throw new Error("initializeWasm() must be awaited first!");
24176 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
24177 return nativeResponseValue;
24179 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
24181 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: number, val: number): void {
24182 if(!isWasmInitialized) {
24183 throw new Error("initializeWasm() must be awaited first!");
24185 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
24186 // debug statements here
24188 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24190 export function CommitmentUpdate_get_update_fee(this_ptr: number): number {
24191 if(!isWasmInitialized) {
24192 throw new Error("initializeWasm() must be awaited first!");
24194 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
24195 return nativeResponseValue;
24197 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
24199 export function CommitmentUpdate_set_update_fee(this_ptr: number, val: number): void {
24200 if(!isWasmInitialized) {
24201 throw new Error("initializeWasm() must be awaited first!");
24203 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
24204 // debug statements here
24206 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24208 export function CommitmentUpdate_get_commitment_signed(this_ptr: number): number {
24209 if(!isWasmInitialized) {
24210 throw new Error("initializeWasm() must be awaited first!");
24212 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
24213 return nativeResponseValue;
24215 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
24217 export function CommitmentUpdate_set_commitment_signed(this_ptr: number, val: number): void {
24218 if(!isWasmInitialized) {
24219 throw new Error("initializeWasm() must be awaited first!");
24221 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
24222 // debug statements here
24224 // 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);
24226 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 {
24227 if(!isWasmInitialized) {
24228 throw new Error("initializeWasm() must be awaited first!");
24230 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);
24231 return nativeResponseValue;
24233 // uintptr_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
24235 export function CommitmentUpdate_clone_ptr(arg: number): number {
24236 if(!isWasmInitialized) {
24237 throw new Error("initializeWasm() must be awaited first!");
24239 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
24240 return nativeResponseValue;
24242 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
24244 export function CommitmentUpdate_clone(orig: number): number {
24245 if(!isWasmInitialized) {
24246 throw new Error("initializeWasm() must be awaited first!");
24248 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
24249 return nativeResponseValue;
24251 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
24253 export function ChannelMessageHandler_free(this_ptr: number): void {
24254 if(!isWasmInitialized) {
24255 throw new Error("initializeWasm() must be awaited first!");
24257 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
24258 // debug statements here
24260 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
24262 export function RoutingMessageHandler_free(this_ptr: number): void {
24263 if(!isWasmInitialized) {
24264 throw new Error("initializeWasm() must be awaited first!");
24266 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
24267 // debug statements here
24269 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
24271 export function AcceptChannel_write(obj: number): number {
24272 if(!isWasmInitialized) {
24273 throw new Error("initializeWasm() must be awaited first!");
24275 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
24276 return nativeResponseValue;
24278 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
24280 export function AcceptChannel_read(ser: number): number {
24281 if(!isWasmInitialized) {
24282 throw new Error("initializeWasm() must be awaited first!");
24284 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
24285 return nativeResponseValue;
24287 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
24289 export function AnnouncementSignatures_write(obj: number): number {
24290 if(!isWasmInitialized) {
24291 throw new Error("initializeWasm() must be awaited first!");
24293 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
24294 return nativeResponseValue;
24296 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
24298 export function AnnouncementSignatures_read(ser: number): number {
24299 if(!isWasmInitialized) {
24300 throw new Error("initializeWasm() must be awaited first!");
24302 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
24303 return nativeResponseValue;
24305 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
24307 export function ChannelReestablish_write(obj: number): number {
24308 if(!isWasmInitialized) {
24309 throw new Error("initializeWasm() must be awaited first!");
24311 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
24312 return nativeResponseValue;
24314 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
24316 export function ChannelReestablish_read(ser: number): number {
24317 if(!isWasmInitialized) {
24318 throw new Error("initializeWasm() must be awaited first!");
24320 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
24321 return nativeResponseValue;
24323 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
24325 export function ClosingSigned_write(obj: number): number {
24326 if(!isWasmInitialized) {
24327 throw new Error("initializeWasm() must be awaited first!");
24329 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
24330 return nativeResponseValue;
24332 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
24334 export function ClosingSigned_read(ser: number): number {
24335 if(!isWasmInitialized) {
24336 throw new Error("initializeWasm() must be awaited first!");
24338 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
24339 return nativeResponseValue;
24341 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
24343 export function ClosingSignedFeeRange_write(obj: number): number {
24344 if(!isWasmInitialized) {
24345 throw new Error("initializeWasm() must be awaited first!");
24347 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
24348 return nativeResponseValue;
24350 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
24352 export function ClosingSignedFeeRange_read(ser: number): number {
24353 if(!isWasmInitialized) {
24354 throw new Error("initializeWasm() must be awaited first!");
24356 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
24357 return nativeResponseValue;
24359 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
24361 export function CommitmentSigned_write(obj: number): number {
24362 if(!isWasmInitialized) {
24363 throw new Error("initializeWasm() must be awaited first!");
24365 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
24366 return nativeResponseValue;
24368 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
24370 export function CommitmentSigned_read(ser: number): number {
24371 if(!isWasmInitialized) {
24372 throw new Error("initializeWasm() must be awaited first!");
24374 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
24375 return nativeResponseValue;
24377 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
24379 export function FundingCreated_write(obj: number): number {
24380 if(!isWasmInitialized) {
24381 throw new Error("initializeWasm() must be awaited first!");
24383 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
24384 return nativeResponseValue;
24386 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
24388 export function FundingCreated_read(ser: number): number {
24389 if(!isWasmInitialized) {
24390 throw new Error("initializeWasm() must be awaited first!");
24392 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
24393 return nativeResponseValue;
24395 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
24397 export function FundingSigned_write(obj: number): number {
24398 if(!isWasmInitialized) {
24399 throw new Error("initializeWasm() must be awaited first!");
24401 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
24402 return nativeResponseValue;
24404 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
24406 export function FundingSigned_read(ser: number): number {
24407 if(!isWasmInitialized) {
24408 throw new Error("initializeWasm() must be awaited first!");
24410 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
24411 return nativeResponseValue;
24413 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
24415 export function ChannelReady_write(obj: number): number {
24416 if(!isWasmInitialized) {
24417 throw new Error("initializeWasm() must be awaited first!");
24419 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
24420 return nativeResponseValue;
24422 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
24424 export function ChannelReady_read(ser: number): number {
24425 if(!isWasmInitialized) {
24426 throw new Error("initializeWasm() must be awaited first!");
24428 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
24429 return nativeResponseValue;
24431 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
24433 export function Init_write(obj: number): number {
24434 if(!isWasmInitialized) {
24435 throw new Error("initializeWasm() must be awaited first!");
24437 const nativeResponseValue = wasm.TS_Init_write(obj);
24438 return nativeResponseValue;
24440 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
24442 export function Init_read(ser: number): number {
24443 if(!isWasmInitialized) {
24444 throw new Error("initializeWasm() must be awaited first!");
24446 const nativeResponseValue = wasm.TS_Init_read(ser);
24447 return nativeResponseValue;
24449 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
24451 export function OpenChannel_write(obj: number): number {
24452 if(!isWasmInitialized) {
24453 throw new Error("initializeWasm() must be awaited first!");
24455 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
24456 return nativeResponseValue;
24458 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
24460 export function OpenChannel_read(ser: number): number {
24461 if(!isWasmInitialized) {
24462 throw new Error("initializeWasm() must be awaited first!");
24464 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
24465 return nativeResponseValue;
24467 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
24469 export function RevokeAndACK_write(obj: number): number {
24470 if(!isWasmInitialized) {
24471 throw new Error("initializeWasm() must be awaited first!");
24473 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
24474 return nativeResponseValue;
24476 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
24478 export function RevokeAndACK_read(ser: number): number {
24479 if(!isWasmInitialized) {
24480 throw new Error("initializeWasm() must be awaited first!");
24482 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
24483 return nativeResponseValue;
24485 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
24487 export function Shutdown_write(obj: number): number {
24488 if(!isWasmInitialized) {
24489 throw new Error("initializeWasm() must be awaited first!");
24491 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
24492 return nativeResponseValue;
24494 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
24496 export function Shutdown_read(ser: number): number {
24497 if(!isWasmInitialized) {
24498 throw new Error("initializeWasm() must be awaited first!");
24500 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
24501 return nativeResponseValue;
24503 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
24505 export function UpdateFailHTLC_write(obj: number): number {
24506 if(!isWasmInitialized) {
24507 throw new Error("initializeWasm() must be awaited first!");
24509 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
24510 return nativeResponseValue;
24512 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
24514 export function UpdateFailHTLC_read(ser: number): number {
24515 if(!isWasmInitialized) {
24516 throw new Error("initializeWasm() must be awaited first!");
24518 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
24519 return nativeResponseValue;
24521 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
24523 export function UpdateFailMalformedHTLC_write(obj: number): number {
24524 if(!isWasmInitialized) {
24525 throw new Error("initializeWasm() must be awaited first!");
24527 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
24528 return nativeResponseValue;
24530 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
24532 export function UpdateFailMalformedHTLC_read(ser: number): number {
24533 if(!isWasmInitialized) {
24534 throw new Error("initializeWasm() must be awaited first!");
24536 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
24537 return nativeResponseValue;
24539 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
24541 export function UpdateFee_write(obj: number): number {
24542 if(!isWasmInitialized) {
24543 throw new Error("initializeWasm() must be awaited first!");
24545 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
24546 return nativeResponseValue;
24548 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
24550 export function UpdateFee_read(ser: number): number {
24551 if(!isWasmInitialized) {
24552 throw new Error("initializeWasm() must be awaited first!");
24554 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
24555 return nativeResponseValue;
24557 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
24559 export function UpdateFulfillHTLC_write(obj: number): number {
24560 if(!isWasmInitialized) {
24561 throw new Error("initializeWasm() must be awaited first!");
24563 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
24564 return nativeResponseValue;
24566 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
24568 export function UpdateFulfillHTLC_read(ser: number): number {
24569 if(!isWasmInitialized) {
24570 throw new Error("initializeWasm() must be awaited first!");
24572 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
24573 return nativeResponseValue;
24575 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
24577 export function UpdateAddHTLC_write(obj: number): number {
24578 if(!isWasmInitialized) {
24579 throw new Error("initializeWasm() must be awaited first!");
24581 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
24582 return nativeResponseValue;
24584 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
24586 export function UpdateAddHTLC_read(ser: number): number {
24587 if(!isWasmInitialized) {
24588 throw new Error("initializeWasm() must be awaited first!");
24590 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
24591 return nativeResponseValue;
24593 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
24595 export function Ping_write(obj: number): number {
24596 if(!isWasmInitialized) {
24597 throw new Error("initializeWasm() must be awaited first!");
24599 const nativeResponseValue = wasm.TS_Ping_write(obj);
24600 return nativeResponseValue;
24602 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
24604 export function Ping_read(ser: number): number {
24605 if(!isWasmInitialized) {
24606 throw new Error("initializeWasm() must be awaited first!");
24608 const nativeResponseValue = wasm.TS_Ping_read(ser);
24609 return nativeResponseValue;
24611 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
24613 export function Pong_write(obj: number): number {
24614 if(!isWasmInitialized) {
24615 throw new Error("initializeWasm() must be awaited first!");
24617 const nativeResponseValue = wasm.TS_Pong_write(obj);
24618 return nativeResponseValue;
24620 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
24622 export function Pong_read(ser: number): number {
24623 if(!isWasmInitialized) {
24624 throw new Error("initializeWasm() must be awaited first!");
24626 const nativeResponseValue = wasm.TS_Pong_read(ser);
24627 return nativeResponseValue;
24629 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
24631 export function UnsignedChannelAnnouncement_write(obj: number): number {
24632 if(!isWasmInitialized) {
24633 throw new Error("initializeWasm() must be awaited first!");
24635 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
24636 return nativeResponseValue;
24638 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
24640 export function UnsignedChannelAnnouncement_read(ser: number): number {
24641 if(!isWasmInitialized) {
24642 throw new Error("initializeWasm() must be awaited first!");
24644 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
24645 return nativeResponseValue;
24647 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
24649 export function ChannelAnnouncement_write(obj: number): number {
24650 if(!isWasmInitialized) {
24651 throw new Error("initializeWasm() must be awaited first!");
24653 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
24654 return nativeResponseValue;
24656 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
24658 export function ChannelAnnouncement_read(ser: number): number {
24659 if(!isWasmInitialized) {
24660 throw new Error("initializeWasm() must be awaited first!");
24662 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
24663 return nativeResponseValue;
24665 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
24667 export function UnsignedChannelUpdate_write(obj: number): number {
24668 if(!isWasmInitialized) {
24669 throw new Error("initializeWasm() must be awaited first!");
24671 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
24672 return nativeResponseValue;
24674 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
24676 export function UnsignedChannelUpdate_read(ser: number): number {
24677 if(!isWasmInitialized) {
24678 throw new Error("initializeWasm() must be awaited first!");
24680 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
24681 return nativeResponseValue;
24683 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
24685 export function ChannelUpdate_write(obj: number): number {
24686 if(!isWasmInitialized) {
24687 throw new Error("initializeWasm() must be awaited first!");
24689 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
24690 return nativeResponseValue;
24692 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
24694 export function ChannelUpdate_read(ser: number): number {
24695 if(!isWasmInitialized) {
24696 throw new Error("initializeWasm() must be awaited first!");
24698 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
24699 return nativeResponseValue;
24701 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
24703 export function ErrorMessage_write(obj: number): number {
24704 if(!isWasmInitialized) {
24705 throw new Error("initializeWasm() must be awaited first!");
24707 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
24708 return nativeResponseValue;
24710 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
24712 export function ErrorMessage_read(ser: number): number {
24713 if(!isWasmInitialized) {
24714 throw new Error("initializeWasm() must be awaited first!");
24716 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
24717 return nativeResponseValue;
24719 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
24721 export function WarningMessage_write(obj: number): number {
24722 if(!isWasmInitialized) {
24723 throw new Error("initializeWasm() must be awaited first!");
24725 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
24726 return nativeResponseValue;
24728 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
24730 export function WarningMessage_read(ser: number): number {
24731 if(!isWasmInitialized) {
24732 throw new Error("initializeWasm() must be awaited first!");
24734 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
24735 return nativeResponseValue;
24737 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
24739 export function UnsignedNodeAnnouncement_write(obj: number): number {
24740 if(!isWasmInitialized) {
24741 throw new Error("initializeWasm() must be awaited first!");
24743 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
24744 return nativeResponseValue;
24746 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
24748 export function UnsignedNodeAnnouncement_read(ser: number): number {
24749 if(!isWasmInitialized) {
24750 throw new Error("initializeWasm() must be awaited first!");
24752 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
24753 return nativeResponseValue;
24755 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
24757 export function NodeAnnouncement_write(obj: number): number {
24758 if(!isWasmInitialized) {
24759 throw new Error("initializeWasm() must be awaited first!");
24761 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
24762 return nativeResponseValue;
24764 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
24766 export function NodeAnnouncement_read(ser: number): number {
24767 if(!isWasmInitialized) {
24768 throw new Error("initializeWasm() must be awaited first!");
24770 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
24771 return nativeResponseValue;
24773 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
24775 export function QueryShortChannelIds_read(ser: number): number {
24776 if(!isWasmInitialized) {
24777 throw new Error("initializeWasm() must be awaited first!");
24779 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
24780 return nativeResponseValue;
24782 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
24784 export function QueryShortChannelIds_write(obj: number): number {
24785 if(!isWasmInitialized) {
24786 throw new Error("initializeWasm() must be awaited first!");
24788 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
24789 return nativeResponseValue;
24791 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
24793 export function ReplyShortChannelIdsEnd_write(obj: number): number {
24794 if(!isWasmInitialized) {
24795 throw new Error("initializeWasm() must be awaited first!");
24797 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
24798 return nativeResponseValue;
24800 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
24802 export function ReplyShortChannelIdsEnd_read(ser: number): number {
24803 if(!isWasmInitialized) {
24804 throw new Error("initializeWasm() must be awaited first!");
24806 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
24807 return nativeResponseValue;
24809 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
24811 export function QueryChannelRange_end_blocknum(this_arg: number): number {
24812 if(!isWasmInitialized) {
24813 throw new Error("initializeWasm() must be awaited first!");
24815 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
24816 return nativeResponseValue;
24818 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
24820 export function QueryChannelRange_write(obj: number): number {
24821 if(!isWasmInitialized) {
24822 throw new Error("initializeWasm() must be awaited first!");
24824 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
24825 return nativeResponseValue;
24827 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
24829 export function QueryChannelRange_read(ser: number): number {
24830 if(!isWasmInitialized) {
24831 throw new Error("initializeWasm() must be awaited first!");
24833 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
24834 return nativeResponseValue;
24836 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
24838 export function ReplyChannelRange_read(ser: number): number {
24839 if(!isWasmInitialized) {
24840 throw new Error("initializeWasm() must be awaited first!");
24842 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
24843 return nativeResponseValue;
24845 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
24847 export function ReplyChannelRange_write(obj: number): number {
24848 if(!isWasmInitialized) {
24849 throw new Error("initializeWasm() must be awaited first!");
24851 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
24852 return nativeResponseValue;
24854 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
24856 export function GossipTimestampFilter_write(obj: number): number {
24857 if(!isWasmInitialized) {
24858 throw new Error("initializeWasm() must be awaited first!");
24860 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
24861 return nativeResponseValue;
24863 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
24865 export function GossipTimestampFilter_read(ser: number): number {
24866 if(!isWasmInitialized) {
24867 throw new Error("initializeWasm() must be awaited first!");
24869 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
24870 return nativeResponseValue;
24872 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
24874 export function CustomMessageHandler_free(this_ptr: number): void {
24875 if(!isWasmInitialized) {
24876 throw new Error("initializeWasm() must be awaited first!");
24878 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
24879 // debug statements here
24881 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
24883 export function IgnoringMessageHandler_free(this_obj: number): void {
24884 if(!isWasmInitialized) {
24885 throw new Error("initializeWasm() must be awaited first!");
24887 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
24888 // debug statements here
24890 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
24892 export function IgnoringMessageHandler_new(): number {
24893 if(!isWasmInitialized) {
24894 throw new Error("initializeWasm() must be awaited first!");
24896 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
24897 return nativeResponseValue;
24899 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24901 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
24902 if(!isWasmInitialized) {
24903 throw new Error("initializeWasm() must be awaited first!");
24905 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
24906 return nativeResponseValue;
24908 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24910 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
24911 if(!isWasmInitialized) {
24912 throw new Error("initializeWasm() must be awaited first!");
24914 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
24915 return nativeResponseValue;
24917 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24919 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: number): number {
24920 if(!isWasmInitialized) {
24921 throw new Error("initializeWasm() must be awaited first!");
24923 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
24924 return nativeResponseValue;
24926 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24928 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: number): number {
24929 if(!isWasmInitialized) {
24930 throw new Error("initializeWasm() must be awaited first!");
24932 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
24933 return nativeResponseValue;
24935 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
24937 export function ErroringMessageHandler_free(this_obj: number): void {
24938 if(!isWasmInitialized) {
24939 throw new Error("initializeWasm() must be awaited first!");
24941 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
24942 // debug statements here
24944 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
24946 export function ErroringMessageHandler_new(): number {
24947 if(!isWasmInitialized) {
24948 throw new Error("initializeWasm() must be awaited first!");
24950 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
24951 return nativeResponseValue;
24953 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
24955 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
24956 if(!isWasmInitialized) {
24957 throw new Error("initializeWasm() must be awaited first!");
24959 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
24960 return nativeResponseValue;
24962 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
24964 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
24965 if(!isWasmInitialized) {
24966 throw new Error("initializeWasm() must be awaited first!");
24968 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
24969 return nativeResponseValue;
24971 // void MessageHandler_free(struct LDKMessageHandler this_obj);
24973 export function MessageHandler_free(this_obj: number): void {
24974 if(!isWasmInitialized) {
24975 throw new Error("initializeWasm() must be awaited first!");
24977 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
24978 // debug statements here
24980 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
24982 export function MessageHandler_get_chan_handler(this_ptr: number): number {
24983 if(!isWasmInitialized) {
24984 throw new Error("initializeWasm() must be awaited first!");
24986 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
24987 return nativeResponseValue;
24989 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
24991 export function MessageHandler_set_chan_handler(this_ptr: number, val: number): void {
24992 if(!isWasmInitialized) {
24993 throw new Error("initializeWasm() must be awaited first!");
24995 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
24996 // debug statements here
24998 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
25000 export function MessageHandler_get_route_handler(this_ptr: number): number {
25001 if(!isWasmInitialized) {
25002 throw new Error("initializeWasm() must be awaited first!");
25004 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
25005 return nativeResponseValue;
25007 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
25009 export function MessageHandler_set_route_handler(this_ptr: number, val: number): void {
25010 if(!isWasmInitialized) {
25011 throw new Error("initializeWasm() must be awaited first!");
25013 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
25014 // debug statements here
25016 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
25018 export function MessageHandler_new(chan_handler_arg: number, route_handler_arg: number): number {
25019 if(!isWasmInitialized) {
25020 throw new Error("initializeWasm() must be awaited first!");
25022 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg);
25023 return nativeResponseValue;
25025 // uintptr_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
25027 export function SocketDescriptor_clone_ptr(arg: number): number {
25028 if(!isWasmInitialized) {
25029 throw new Error("initializeWasm() must be awaited first!");
25031 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
25032 return nativeResponseValue;
25034 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
25036 export function SocketDescriptor_clone(orig: number): number {
25037 if(!isWasmInitialized) {
25038 throw new Error("initializeWasm() must be awaited first!");
25040 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
25041 return nativeResponseValue;
25043 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
25045 export function SocketDescriptor_free(this_ptr: number): void {
25046 if(!isWasmInitialized) {
25047 throw new Error("initializeWasm() must be awaited first!");
25049 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
25050 // debug statements here
25052 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
25054 export function PeerHandleError_free(this_obj: number): void {
25055 if(!isWasmInitialized) {
25056 throw new Error("initializeWasm() must be awaited first!");
25058 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
25059 // debug statements here
25061 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
25063 export function PeerHandleError_get_no_connection_possible(this_ptr: number): boolean {
25064 if(!isWasmInitialized) {
25065 throw new Error("initializeWasm() must be awaited first!");
25067 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
25068 return nativeResponseValue;
25070 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
25072 export function PeerHandleError_set_no_connection_possible(this_ptr: number, val: boolean): void {
25073 if(!isWasmInitialized) {
25074 throw new Error("initializeWasm() must be awaited first!");
25076 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
25077 // debug statements here
25079 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
25081 export function PeerHandleError_new(no_connection_possible_arg: boolean): number {
25082 if(!isWasmInitialized) {
25083 throw new Error("initializeWasm() must be awaited first!");
25085 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
25086 return nativeResponseValue;
25088 // uintptr_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
25090 export function PeerHandleError_clone_ptr(arg: number): number {
25091 if(!isWasmInitialized) {
25092 throw new Error("initializeWasm() must be awaited first!");
25094 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
25095 return nativeResponseValue;
25097 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
25099 export function PeerHandleError_clone(orig: number): number {
25100 if(!isWasmInitialized) {
25101 throw new Error("initializeWasm() must be awaited first!");
25103 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
25104 return nativeResponseValue;
25106 // void PeerManager_free(struct LDKPeerManager this_obj);
25108 export function PeerManager_free(this_obj: number): void {
25109 if(!isWasmInitialized) {
25110 throw new Error("initializeWasm() must be awaited first!");
25112 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
25113 // debug statements here
25115 // 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);
25117 export function PeerManager_new(message_handler: number, our_node_secret: number, ephemeral_random_data: number, logger: number, custom_message_handler: number): number {
25118 if(!isWasmInitialized) {
25119 throw new Error("initializeWasm() must be awaited first!");
25121 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, ephemeral_random_data, logger, custom_message_handler);
25122 return nativeResponseValue;
25124 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
25126 export function PeerManager_get_peer_node_ids(this_arg: number): number {
25127 if(!isWasmInitialized) {
25128 throw new Error("initializeWasm() must be awaited first!");
25130 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
25131 return nativeResponseValue;
25133 // 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);
25135 export function PeerManager_new_outbound_connection(this_arg: number, their_node_id: number, descriptor: number, remote_network_address: number): number {
25136 if(!isWasmInitialized) {
25137 throw new Error("initializeWasm() must be awaited first!");
25139 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
25140 return nativeResponseValue;
25142 // 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);
25144 export function PeerManager_new_inbound_connection(this_arg: number, descriptor: number, remote_network_address: number): number {
25145 if(!isWasmInitialized) {
25146 throw new Error("initializeWasm() must be awaited first!");
25148 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
25149 return nativeResponseValue;
25151 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
25153 export function PeerManager_write_buffer_space_avail(this_arg: number, descriptor: number): number {
25154 if(!isWasmInitialized) {
25155 throw new Error("initializeWasm() must be awaited first!");
25157 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
25158 return nativeResponseValue;
25160 // 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);
25162 export function PeerManager_read_event(this_arg: number, peer_descriptor: number, data: number): number {
25163 if(!isWasmInitialized) {
25164 throw new Error("initializeWasm() must be awaited first!");
25166 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
25167 return nativeResponseValue;
25169 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
25171 export function PeerManager_process_events(this_arg: number): void {
25172 if(!isWasmInitialized) {
25173 throw new Error("initializeWasm() must be awaited first!");
25175 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
25176 // debug statements here
25178 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
25180 export function PeerManager_socket_disconnected(this_arg: number, descriptor: number): void {
25181 if(!isWasmInitialized) {
25182 throw new Error("initializeWasm() must be awaited first!");
25184 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
25185 // debug statements here
25187 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
25189 export function PeerManager_disconnect_by_node_id(this_arg: number, node_id: number, no_connection_possible: boolean): void {
25190 if(!isWasmInitialized) {
25191 throw new Error("initializeWasm() must be awaited first!");
25193 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
25194 // debug statements here
25196 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
25198 export function PeerManager_disconnect_all_peers(this_arg: number): void {
25199 if(!isWasmInitialized) {
25200 throw new Error("initializeWasm() must be awaited first!");
25202 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
25203 // debug statements here
25205 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
25207 export function PeerManager_timer_tick_occurred(this_arg: number): void {
25208 if(!isWasmInitialized) {
25209 throw new Error("initializeWasm() must be awaited first!");
25211 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
25212 // debug statements here
25214 // uint64_t htlc_success_tx_weight(bool opt_anchors);
25216 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
25217 if(!isWasmInitialized) {
25218 throw new Error("initializeWasm() must be awaited first!");
25220 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
25221 return nativeResponseValue;
25223 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
25225 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
25226 if(!isWasmInitialized) {
25227 throw new Error("initializeWasm() must be awaited first!");
25229 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
25230 return nativeResponseValue;
25232 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
25234 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
25235 if(!isWasmInitialized) {
25236 throw new Error("initializeWasm() must be awaited first!");
25238 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
25239 return nativeResponseValue;
25241 // 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);
25243 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 {
25244 if(!isWasmInitialized) {
25245 throw new Error("initializeWasm() must be awaited first!");
25247 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
25248 return nativeResponseValue;
25250 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
25252 export function CounterpartyCommitmentSecrets_free(this_obj: number): void {
25253 if(!isWasmInitialized) {
25254 throw new Error("initializeWasm() must be awaited first!");
25256 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
25257 // debug statements here
25259 // uintptr_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
25261 export function CounterpartyCommitmentSecrets_clone_ptr(arg: number): number {
25262 if(!isWasmInitialized) {
25263 throw new Error("initializeWasm() must be awaited first!");
25265 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
25266 return nativeResponseValue;
25268 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
25270 export function CounterpartyCommitmentSecrets_clone(orig: number): number {
25271 if(!isWasmInitialized) {
25272 throw new Error("initializeWasm() must be awaited first!");
25274 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
25275 return nativeResponseValue;
25277 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
25279 export function CounterpartyCommitmentSecrets_new(): number {
25280 if(!isWasmInitialized) {
25281 throw new Error("initializeWasm() must be awaited first!");
25283 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
25284 return nativeResponseValue;
25286 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
25288 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: number): bigint {
25289 if(!isWasmInitialized) {
25290 throw new Error("initializeWasm() must be awaited first!");
25292 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
25293 return nativeResponseValue;
25295 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
25297 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: number, idx: bigint, secret: number): number {
25298 if(!isWasmInitialized) {
25299 throw new Error("initializeWasm() must be awaited first!");
25301 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
25302 return nativeResponseValue;
25304 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
25306 export function CounterpartyCommitmentSecrets_get_secret(this_arg: number, idx: bigint): number {
25307 if(!isWasmInitialized) {
25308 throw new Error("initializeWasm() must be awaited first!");
25310 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
25311 return nativeResponseValue;
25313 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
25315 export function CounterpartyCommitmentSecrets_write(obj: number): number {
25316 if(!isWasmInitialized) {
25317 throw new Error("initializeWasm() must be awaited first!");
25319 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
25320 return nativeResponseValue;
25322 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
25324 export function CounterpartyCommitmentSecrets_read(ser: number): number {
25325 if(!isWasmInitialized) {
25326 throw new Error("initializeWasm() must be awaited first!");
25328 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
25329 return nativeResponseValue;
25331 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
25333 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
25334 if(!isWasmInitialized) {
25335 throw new Error("initializeWasm() must be awaited first!");
25337 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
25338 return nativeResponseValue;
25340 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
25342 export function derive_public_key(per_commitment_point: number, base_point: number): number {
25343 if(!isWasmInitialized) {
25344 throw new Error("initializeWasm() must be awaited first!");
25346 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
25347 return nativeResponseValue;
25349 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
25351 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
25352 if(!isWasmInitialized) {
25353 throw new Error("initializeWasm() must be awaited first!");
25355 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
25356 return nativeResponseValue;
25358 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
25360 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
25361 if(!isWasmInitialized) {
25362 throw new Error("initializeWasm() must be awaited first!");
25364 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
25365 return nativeResponseValue;
25367 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
25369 export function TxCreationKeys_free(this_obj: number): void {
25370 if(!isWasmInitialized) {
25371 throw new Error("initializeWasm() must be awaited first!");
25373 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
25374 // debug statements here
25376 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25378 export function TxCreationKeys_get_per_commitment_point(this_ptr: number): number {
25379 if(!isWasmInitialized) {
25380 throw new Error("initializeWasm() must be awaited first!");
25382 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
25383 return nativeResponseValue;
25385 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25387 export function TxCreationKeys_set_per_commitment_point(this_ptr: number, val: number): void {
25388 if(!isWasmInitialized) {
25389 throw new Error("initializeWasm() must be awaited first!");
25391 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
25392 // debug statements here
25394 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25396 export function TxCreationKeys_get_revocation_key(this_ptr: number): number {
25397 if(!isWasmInitialized) {
25398 throw new Error("initializeWasm() must be awaited first!");
25400 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
25401 return nativeResponseValue;
25403 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25405 export function TxCreationKeys_set_revocation_key(this_ptr: number, val: number): void {
25406 if(!isWasmInitialized) {
25407 throw new Error("initializeWasm() must be awaited first!");
25409 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
25410 // debug statements here
25412 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25414 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: number): number {
25415 if(!isWasmInitialized) {
25416 throw new Error("initializeWasm() must be awaited first!");
25418 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
25419 return nativeResponseValue;
25421 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25423 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: number, val: number): void {
25424 if(!isWasmInitialized) {
25425 throw new Error("initializeWasm() must be awaited first!");
25427 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
25428 // debug statements here
25430 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25432 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: number): number {
25433 if(!isWasmInitialized) {
25434 throw new Error("initializeWasm() must be awaited first!");
25436 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
25437 return nativeResponseValue;
25439 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25441 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: number, val: number): void {
25442 if(!isWasmInitialized) {
25443 throw new Error("initializeWasm() must be awaited first!");
25445 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
25446 // debug statements here
25448 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25450 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: number): number {
25451 if(!isWasmInitialized) {
25452 throw new Error("initializeWasm() must be awaited first!");
25454 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
25455 return nativeResponseValue;
25457 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25459 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: number, val: number): void {
25460 if(!isWasmInitialized) {
25461 throw new Error("initializeWasm() must be awaited first!");
25463 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
25464 // debug statements here
25466 // 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);
25468 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 {
25469 if(!isWasmInitialized) {
25470 throw new Error("initializeWasm() must be awaited first!");
25472 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);
25473 return nativeResponseValue;
25475 // uintptr_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
25477 export function TxCreationKeys_clone_ptr(arg: number): number {
25478 if(!isWasmInitialized) {
25479 throw new Error("initializeWasm() must be awaited first!");
25481 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
25482 return nativeResponseValue;
25484 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
25486 export function TxCreationKeys_clone(orig: number): number {
25487 if(!isWasmInitialized) {
25488 throw new Error("initializeWasm() must be awaited first!");
25490 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
25491 return nativeResponseValue;
25493 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
25495 export function TxCreationKeys_write(obj: number): number {
25496 if(!isWasmInitialized) {
25497 throw new Error("initializeWasm() must be awaited first!");
25499 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
25500 return nativeResponseValue;
25502 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
25504 export function TxCreationKeys_read(ser: number): number {
25505 if(!isWasmInitialized) {
25506 throw new Error("initializeWasm() must be awaited first!");
25508 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
25509 return nativeResponseValue;
25511 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
25513 export function ChannelPublicKeys_free(this_obj: number): void {
25514 if(!isWasmInitialized) {
25515 throw new Error("initializeWasm() must be awaited first!");
25517 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
25518 // debug statements here
25520 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25522 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: number): number {
25523 if(!isWasmInitialized) {
25524 throw new Error("initializeWasm() must be awaited first!");
25526 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
25527 return nativeResponseValue;
25529 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25531 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: number, val: number): void {
25532 if(!isWasmInitialized) {
25533 throw new Error("initializeWasm() must be awaited first!");
25535 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
25536 // debug statements here
25538 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25540 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: number): number {
25541 if(!isWasmInitialized) {
25542 throw new Error("initializeWasm() must be awaited first!");
25544 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
25545 return nativeResponseValue;
25547 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25549 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: number, val: number): void {
25550 if(!isWasmInitialized) {
25551 throw new Error("initializeWasm() must be awaited first!");
25553 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
25554 // debug statements here
25556 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25558 export function ChannelPublicKeys_get_payment_point(this_ptr: number): number {
25559 if(!isWasmInitialized) {
25560 throw new Error("initializeWasm() must be awaited first!");
25562 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
25563 return nativeResponseValue;
25565 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25567 export function ChannelPublicKeys_set_payment_point(this_ptr: number, val: number): void {
25568 if(!isWasmInitialized) {
25569 throw new Error("initializeWasm() must be awaited first!");
25571 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
25572 // debug statements here
25574 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25576 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: number): number {
25577 if(!isWasmInitialized) {
25578 throw new Error("initializeWasm() must be awaited first!");
25580 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
25581 return nativeResponseValue;
25583 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25585 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
25586 if(!isWasmInitialized) {
25587 throw new Error("initializeWasm() must be awaited first!");
25589 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
25590 // debug statements here
25592 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25594 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: number): number {
25595 if(!isWasmInitialized) {
25596 throw new Error("initializeWasm() must be awaited first!");
25598 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
25599 return nativeResponseValue;
25601 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25603 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: number, val: number): void {
25604 if(!isWasmInitialized) {
25605 throw new Error("initializeWasm() must be awaited first!");
25607 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
25608 // debug statements here
25610 // 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);
25612 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 {
25613 if(!isWasmInitialized) {
25614 throw new Error("initializeWasm() must be awaited first!");
25616 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
25617 return nativeResponseValue;
25619 // uintptr_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
25621 export function ChannelPublicKeys_clone_ptr(arg: number): number {
25622 if(!isWasmInitialized) {
25623 throw new Error("initializeWasm() must be awaited first!");
25625 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
25626 return nativeResponseValue;
25628 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
25630 export function ChannelPublicKeys_clone(orig: number): number {
25631 if(!isWasmInitialized) {
25632 throw new Error("initializeWasm() must be awaited first!");
25634 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
25635 return nativeResponseValue;
25637 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
25639 export function ChannelPublicKeys_write(obj: number): number {
25640 if(!isWasmInitialized) {
25641 throw new Error("initializeWasm() must be awaited first!");
25643 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
25644 return nativeResponseValue;
25646 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
25648 export function ChannelPublicKeys_read(ser: number): number {
25649 if(!isWasmInitialized) {
25650 throw new Error("initializeWasm() must be awaited first!");
25652 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
25653 return nativeResponseValue;
25655 // 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);
25657 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 {
25658 if(!isWasmInitialized) {
25659 throw new Error("initializeWasm() must be awaited first!");
25661 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
25662 return nativeResponseValue;
25664 // 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);
25666 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: number, countersignatory_keys: number): number {
25667 if(!isWasmInitialized) {
25668 throw new Error("initializeWasm() must be awaited first!");
25670 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
25671 return nativeResponseValue;
25673 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
25675 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
25676 if(!isWasmInitialized) {
25677 throw new Error("initializeWasm() must be awaited first!");
25679 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
25680 return nativeResponseValue;
25682 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
25684 export function HTLCOutputInCommitment_free(this_obj: number): void {
25685 if(!isWasmInitialized) {
25686 throw new Error("initializeWasm() must be awaited first!");
25688 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
25689 // debug statements here
25691 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25693 export function HTLCOutputInCommitment_get_offered(this_ptr: number): boolean {
25694 if(!isWasmInitialized) {
25695 throw new Error("initializeWasm() must be awaited first!");
25697 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
25698 return nativeResponseValue;
25700 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
25702 export function HTLCOutputInCommitment_set_offered(this_ptr: number, val: boolean): void {
25703 if(!isWasmInitialized) {
25704 throw new Error("initializeWasm() must be awaited first!");
25706 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
25707 // debug statements here
25709 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25711 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: number): bigint {
25712 if(!isWasmInitialized) {
25713 throw new Error("initializeWasm() must be awaited first!");
25715 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
25716 return nativeResponseValue;
25718 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
25720 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: number, val: bigint): void {
25721 if(!isWasmInitialized) {
25722 throw new Error("initializeWasm() must be awaited first!");
25724 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
25725 // debug statements here
25727 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25729 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: number): number {
25730 if(!isWasmInitialized) {
25731 throw new Error("initializeWasm() must be awaited first!");
25733 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
25734 return nativeResponseValue;
25736 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
25738 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: number, val: number): void {
25739 if(!isWasmInitialized) {
25740 throw new Error("initializeWasm() must be awaited first!");
25742 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
25743 // debug statements here
25745 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
25747 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: number): number {
25748 if(!isWasmInitialized) {
25749 throw new Error("initializeWasm() must be awaited first!");
25751 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
25752 return nativeResponseValue;
25754 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25756 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: number, val: number): void {
25757 if(!isWasmInitialized) {
25758 throw new Error("initializeWasm() must be awaited first!");
25760 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
25761 // debug statements here
25763 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25765 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
25766 if(!isWasmInitialized) {
25767 throw new Error("initializeWasm() must be awaited first!");
25769 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
25770 return nativeResponseValue;
25772 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
25774 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: number, val: number): void {
25775 if(!isWasmInitialized) {
25776 throw new Error("initializeWasm() must be awaited first!");
25778 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
25779 // debug statements here
25781 // 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);
25783 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 {
25784 if(!isWasmInitialized) {
25785 throw new Error("initializeWasm() must be awaited first!");
25787 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
25788 return nativeResponseValue;
25790 // uintptr_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
25792 export function HTLCOutputInCommitment_clone_ptr(arg: number): number {
25793 if(!isWasmInitialized) {
25794 throw new Error("initializeWasm() must be awaited first!");
25796 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
25797 return nativeResponseValue;
25799 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
25801 export function HTLCOutputInCommitment_clone(orig: number): number {
25802 if(!isWasmInitialized) {
25803 throw new Error("initializeWasm() must be awaited first!");
25805 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
25806 return nativeResponseValue;
25808 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
25810 export function HTLCOutputInCommitment_write(obj: number): number {
25811 if(!isWasmInitialized) {
25812 throw new Error("initializeWasm() must be awaited first!");
25814 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
25815 return nativeResponseValue;
25817 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
25819 export function HTLCOutputInCommitment_read(ser: number): number {
25820 if(!isWasmInitialized) {
25821 throw new Error("initializeWasm() must be awaited first!");
25823 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
25824 return nativeResponseValue;
25826 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
25828 export function get_htlc_redeemscript(htlc: number, opt_anchors: boolean, keys: number): number {
25829 if(!isWasmInitialized) {
25830 throw new Error("initializeWasm() must be awaited first!");
25832 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
25833 return nativeResponseValue;
25835 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
25837 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
25838 if(!isWasmInitialized) {
25839 throw new Error("initializeWasm() must be awaited first!");
25841 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
25842 return nativeResponseValue;
25844 // 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);
25846 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 {
25847 if(!isWasmInitialized) {
25848 throw new Error("initializeWasm() must be awaited first!");
25850 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
25851 return nativeResponseValue;
25853 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
25855 export function get_anchor_redeemscript(funding_pubkey: number): number {
25856 if(!isWasmInitialized) {
25857 throw new Error("initializeWasm() must be awaited first!");
25859 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
25860 return nativeResponseValue;
25862 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
25864 export function ChannelTransactionParameters_free(this_obj: number): void {
25865 if(!isWasmInitialized) {
25866 throw new Error("initializeWasm() must be awaited first!");
25868 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
25869 // debug statements here
25871 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25873 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: number): number {
25874 if(!isWasmInitialized) {
25875 throw new Error("initializeWasm() must be awaited first!");
25877 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
25878 return nativeResponseValue;
25880 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
25882 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: number, val: number): void {
25883 if(!isWasmInitialized) {
25884 throw new Error("initializeWasm() must be awaited first!");
25886 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
25887 // debug statements here
25889 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25891 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: number): number {
25892 if(!isWasmInitialized) {
25893 throw new Error("initializeWasm() must be awaited first!");
25895 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
25896 return nativeResponseValue;
25898 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
25900 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: number, val: number): void {
25901 if(!isWasmInitialized) {
25902 throw new Error("initializeWasm() must be awaited first!");
25904 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
25905 // debug statements here
25907 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25909 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: number): boolean {
25910 if(!isWasmInitialized) {
25911 throw new Error("initializeWasm() must be awaited first!");
25913 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
25914 return nativeResponseValue;
25916 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
25918 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: number, val: boolean): void {
25919 if(!isWasmInitialized) {
25920 throw new Error("initializeWasm() must be awaited first!");
25922 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
25923 // debug statements here
25925 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25927 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: number): number {
25928 if(!isWasmInitialized) {
25929 throw new Error("initializeWasm() must be awaited first!");
25931 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
25932 return nativeResponseValue;
25934 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
25936 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: number, val: number): void {
25937 if(!isWasmInitialized) {
25938 throw new Error("initializeWasm() must be awaited first!");
25940 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
25941 // debug statements here
25943 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25945 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: number): number {
25946 if(!isWasmInitialized) {
25947 throw new Error("initializeWasm() must be awaited first!");
25949 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
25950 return nativeResponseValue;
25952 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
25954 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: number, val: number): void {
25955 if(!isWasmInitialized) {
25956 throw new Error("initializeWasm() must be awaited first!");
25958 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
25959 // debug statements here
25961 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25963 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: number): COption_NoneZ {
25964 if(!isWasmInitialized) {
25965 throw new Error("initializeWasm() must be awaited first!");
25967 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
25968 return nativeResponseValue;
25970 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
25972 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: number, val: COption_NoneZ): void {
25973 if(!isWasmInitialized) {
25974 throw new Error("initializeWasm() must be awaited first!");
25976 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
25977 // debug statements here
25979 // 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);
25981 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 {
25982 if(!isWasmInitialized) {
25983 throw new Error("initializeWasm() must be awaited first!");
25985 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);
25986 return nativeResponseValue;
25988 // uintptr_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
25990 export function ChannelTransactionParameters_clone_ptr(arg: number): number {
25991 if(!isWasmInitialized) {
25992 throw new Error("initializeWasm() must be awaited first!");
25994 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
25995 return nativeResponseValue;
25997 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
25999 export function ChannelTransactionParameters_clone(orig: number): number {
26000 if(!isWasmInitialized) {
26001 throw new Error("initializeWasm() must be awaited first!");
26003 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
26004 return nativeResponseValue;
26006 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
26008 export function CounterpartyChannelTransactionParameters_free(this_obj: number): void {
26009 if(!isWasmInitialized) {
26010 throw new Error("initializeWasm() must be awaited first!");
26012 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
26013 // debug statements here
26015 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
26017 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: number): number {
26018 if(!isWasmInitialized) {
26019 throw new Error("initializeWasm() must be awaited first!");
26021 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
26022 return nativeResponseValue;
26024 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
26026 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: number, val: number): void {
26027 if(!isWasmInitialized) {
26028 throw new Error("initializeWasm() must be awaited first!");
26030 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
26031 // debug statements here
26033 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
26035 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: number): number {
26036 if(!isWasmInitialized) {
26037 throw new Error("initializeWasm() must be awaited first!");
26039 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
26040 return nativeResponseValue;
26042 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
26044 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: number, val: number): void {
26045 if(!isWasmInitialized) {
26046 throw new Error("initializeWasm() must be awaited first!");
26048 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
26049 // debug statements here
26051 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
26053 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: number, selected_contest_delay_arg: number): number {
26054 if(!isWasmInitialized) {
26055 throw new Error("initializeWasm() must be awaited first!");
26057 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
26058 return nativeResponseValue;
26060 // uintptr_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
26062 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: number): number {
26063 if(!isWasmInitialized) {
26064 throw new Error("initializeWasm() must be awaited first!");
26066 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
26067 return nativeResponseValue;
26069 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
26071 export function CounterpartyChannelTransactionParameters_clone(orig: number): number {
26072 if(!isWasmInitialized) {
26073 throw new Error("initializeWasm() must be awaited first!");
26075 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
26076 return nativeResponseValue;
26078 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26080 export function ChannelTransactionParameters_is_populated(this_arg: number): boolean {
26081 if(!isWasmInitialized) {
26082 throw new Error("initializeWasm() must be awaited first!");
26084 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
26085 return nativeResponseValue;
26087 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26089 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: number): number {
26090 if(!isWasmInitialized) {
26091 throw new Error("initializeWasm() must be awaited first!");
26093 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
26094 return nativeResponseValue;
26096 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26098 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: number): number {
26099 if(!isWasmInitialized) {
26100 throw new Error("initializeWasm() must be awaited first!");
26102 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
26103 return nativeResponseValue;
26105 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
26107 export function CounterpartyChannelTransactionParameters_write(obj: number): number {
26108 if(!isWasmInitialized) {
26109 throw new Error("initializeWasm() must be awaited first!");
26111 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
26112 return nativeResponseValue;
26114 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
26116 export function CounterpartyChannelTransactionParameters_read(ser: number): number {
26117 if(!isWasmInitialized) {
26118 throw new Error("initializeWasm() must be awaited first!");
26120 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
26121 return nativeResponseValue;
26123 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
26125 export function ChannelTransactionParameters_write(obj: number): number {
26126 if(!isWasmInitialized) {
26127 throw new Error("initializeWasm() must be awaited first!");
26129 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
26130 return nativeResponseValue;
26132 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
26134 export function ChannelTransactionParameters_read(ser: number): number {
26135 if(!isWasmInitialized) {
26136 throw new Error("initializeWasm() must be awaited first!");
26138 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
26139 return nativeResponseValue;
26141 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
26143 export function DirectedChannelTransactionParameters_free(this_obj: number): void {
26144 if(!isWasmInitialized) {
26145 throw new Error("initializeWasm() must be awaited first!");
26147 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
26148 // debug statements here
26150 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26152 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: number): number {
26153 if(!isWasmInitialized) {
26154 throw new Error("initializeWasm() must be awaited first!");
26156 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
26157 return nativeResponseValue;
26159 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26161 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: number): number {
26162 if(!isWasmInitialized) {
26163 throw new Error("initializeWasm() must be awaited first!");
26165 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
26166 return nativeResponseValue;
26168 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26170 export function DirectedChannelTransactionParameters_contest_delay(this_arg: number): number {
26171 if(!isWasmInitialized) {
26172 throw new Error("initializeWasm() must be awaited first!");
26174 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
26175 return nativeResponseValue;
26177 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26179 export function DirectedChannelTransactionParameters_is_outbound(this_arg: number): boolean {
26180 if(!isWasmInitialized) {
26181 throw new Error("initializeWasm() must be awaited first!");
26183 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
26184 return nativeResponseValue;
26186 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26188 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: number): number {
26189 if(!isWasmInitialized) {
26190 throw new Error("initializeWasm() must be awaited first!");
26192 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
26193 return nativeResponseValue;
26195 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26197 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: number): boolean {
26198 if(!isWasmInitialized) {
26199 throw new Error("initializeWasm() must be awaited first!");
26201 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
26202 return nativeResponseValue;
26204 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
26206 export function HolderCommitmentTransaction_free(this_obj: number): void {
26207 if(!isWasmInitialized) {
26208 throw new Error("initializeWasm() must be awaited first!");
26210 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
26211 // debug statements here
26213 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
26215 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: number): number {
26216 if(!isWasmInitialized) {
26217 throw new Error("initializeWasm() must be awaited first!");
26219 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
26220 return nativeResponseValue;
26222 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
26224 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: number, val: number): void {
26225 if(!isWasmInitialized) {
26226 throw new Error("initializeWasm() must be awaited first!");
26228 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
26229 // debug statements here
26231 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
26233 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: number, val: number): void {
26234 if(!isWasmInitialized) {
26235 throw new Error("initializeWasm() must be awaited first!");
26237 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
26238 // debug statements here
26240 // uintptr_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
26242 export function HolderCommitmentTransaction_clone_ptr(arg: number): number {
26243 if(!isWasmInitialized) {
26244 throw new Error("initializeWasm() must be awaited first!");
26246 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
26247 return nativeResponseValue;
26249 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
26251 export function HolderCommitmentTransaction_clone(orig: number): number {
26252 if(!isWasmInitialized) {
26253 throw new Error("initializeWasm() must be awaited first!");
26255 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
26256 return nativeResponseValue;
26258 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
26260 export function HolderCommitmentTransaction_write(obj: number): number {
26261 if(!isWasmInitialized) {
26262 throw new Error("initializeWasm() must be awaited first!");
26264 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
26265 return nativeResponseValue;
26267 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
26269 export function HolderCommitmentTransaction_read(ser: number): number {
26270 if(!isWasmInitialized) {
26271 throw new Error("initializeWasm() must be awaited first!");
26273 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
26274 return nativeResponseValue;
26276 // 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);
26278 export function HolderCommitmentTransaction_new(commitment_tx: number, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): number {
26279 if(!isWasmInitialized) {
26280 throw new Error("initializeWasm() must be awaited first!");
26282 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
26283 return nativeResponseValue;
26285 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
26287 export function BuiltCommitmentTransaction_free(this_obj: number): void {
26288 if(!isWasmInitialized) {
26289 throw new Error("initializeWasm() must be awaited first!");
26291 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
26292 // debug statements here
26294 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
26296 export function BuiltCommitmentTransaction_get_transaction(this_ptr: number): number {
26297 if(!isWasmInitialized) {
26298 throw new Error("initializeWasm() must be awaited first!");
26300 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
26301 return nativeResponseValue;
26303 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
26305 export function BuiltCommitmentTransaction_set_transaction(this_ptr: number, val: number): void {
26306 if(!isWasmInitialized) {
26307 throw new Error("initializeWasm() must be awaited first!");
26309 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
26310 // debug statements here
26312 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
26314 export function BuiltCommitmentTransaction_get_txid(this_ptr: number): number {
26315 if(!isWasmInitialized) {
26316 throw new Error("initializeWasm() must be awaited first!");
26318 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
26319 return nativeResponseValue;
26321 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26323 export function BuiltCommitmentTransaction_set_txid(this_ptr: number, val: number): void {
26324 if(!isWasmInitialized) {
26325 throw new Error("initializeWasm() must be awaited first!");
26327 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
26328 // debug statements here
26330 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
26332 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): number {
26333 if(!isWasmInitialized) {
26334 throw new Error("initializeWasm() must be awaited first!");
26336 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
26337 return nativeResponseValue;
26339 // uintptr_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
26341 export function BuiltCommitmentTransaction_clone_ptr(arg: number): number {
26342 if(!isWasmInitialized) {
26343 throw new Error("initializeWasm() must be awaited first!");
26345 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
26346 return nativeResponseValue;
26348 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
26350 export function BuiltCommitmentTransaction_clone(orig: number): number {
26351 if(!isWasmInitialized) {
26352 throw new Error("initializeWasm() must be awaited first!");
26354 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
26355 return nativeResponseValue;
26357 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
26359 export function BuiltCommitmentTransaction_write(obj: number): number {
26360 if(!isWasmInitialized) {
26361 throw new Error("initializeWasm() must be awaited first!");
26363 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
26364 return nativeResponseValue;
26366 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
26368 export function BuiltCommitmentTransaction_read(ser: number): number {
26369 if(!isWasmInitialized) {
26370 throw new Error("initializeWasm() must be awaited first!");
26372 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
26373 return nativeResponseValue;
26375 // 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);
26377 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26378 if(!isWasmInitialized) {
26379 throw new Error("initializeWasm() must be awaited first!");
26381 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
26382 return nativeResponseValue;
26384 // 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);
26386 export function BuiltCommitmentTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26387 if(!isWasmInitialized) {
26388 throw new Error("initializeWasm() must be awaited first!");
26390 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
26391 return nativeResponseValue;
26393 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
26395 export function ClosingTransaction_free(this_obj: number): void {
26396 if(!isWasmInitialized) {
26397 throw new Error("initializeWasm() must be awaited first!");
26399 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
26400 // debug statements here
26402 // uintptr_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
26404 export function ClosingTransaction_clone_ptr(arg: number): number {
26405 if(!isWasmInitialized) {
26406 throw new Error("initializeWasm() must be awaited first!");
26408 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
26409 return nativeResponseValue;
26411 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
26413 export function ClosingTransaction_clone(orig: number): number {
26414 if(!isWasmInitialized) {
26415 throw new Error("initializeWasm() must be awaited first!");
26417 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
26418 return nativeResponseValue;
26420 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
26422 export function ClosingTransaction_hash(o: number): bigint {
26423 if(!isWasmInitialized) {
26424 throw new Error("initializeWasm() must be awaited first!");
26426 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
26427 return nativeResponseValue;
26429 // 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);
26431 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 {
26432 if(!isWasmInitialized) {
26433 throw new Error("initializeWasm() must be awaited first!");
26435 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
26436 return nativeResponseValue;
26438 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26440 export function ClosingTransaction_trust(this_arg: number): number {
26441 if(!isWasmInitialized) {
26442 throw new Error("initializeWasm() must be awaited first!");
26444 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
26445 return nativeResponseValue;
26447 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
26449 export function ClosingTransaction_verify(this_arg: number, funding_outpoint: number): number {
26450 if(!isWasmInitialized) {
26451 throw new Error("initializeWasm() must be awaited first!");
26453 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
26454 return nativeResponseValue;
26456 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26458 export function ClosingTransaction_to_holder_value_sat(this_arg: number): bigint {
26459 if(!isWasmInitialized) {
26460 throw new Error("initializeWasm() must be awaited first!");
26462 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
26463 return nativeResponseValue;
26465 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26467 export function ClosingTransaction_to_counterparty_value_sat(this_arg: number): bigint {
26468 if(!isWasmInitialized) {
26469 throw new Error("initializeWasm() must be awaited first!");
26471 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
26472 return nativeResponseValue;
26474 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26476 export function ClosingTransaction_to_holder_script(this_arg: number): number {
26477 if(!isWasmInitialized) {
26478 throw new Error("initializeWasm() must be awaited first!");
26480 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
26481 return nativeResponseValue;
26483 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26485 export function ClosingTransaction_to_counterparty_script(this_arg: number): number {
26486 if(!isWasmInitialized) {
26487 throw new Error("initializeWasm() must be awaited first!");
26489 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
26490 return nativeResponseValue;
26492 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
26494 export function TrustedClosingTransaction_free(this_obj: number): void {
26495 if(!isWasmInitialized) {
26496 throw new Error("initializeWasm() must be awaited first!");
26498 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
26499 // debug statements here
26501 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
26503 export function TrustedClosingTransaction_built_transaction(this_arg: number): number {
26504 if(!isWasmInitialized) {
26505 throw new Error("initializeWasm() must be awaited first!");
26507 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
26508 return nativeResponseValue;
26510 // 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);
26512 export function TrustedClosingTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26513 if(!isWasmInitialized) {
26514 throw new Error("initializeWasm() must be awaited first!");
26516 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
26517 return nativeResponseValue;
26519 // 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);
26521 export function TrustedClosingTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26522 if(!isWasmInitialized) {
26523 throw new Error("initializeWasm() must be awaited first!");
26525 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
26526 return nativeResponseValue;
26528 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
26530 export function CommitmentTransaction_free(this_obj: number): void {
26531 if(!isWasmInitialized) {
26532 throw new Error("initializeWasm() must be awaited first!");
26534 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
26535 // debug statements here
26537 // uintptr_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
26539 export function CommitmentTransaction_clone_ptr(arg: number): number {
26540 if(!isWasmInitialized) {
26541 throw new Error("initializeWasm() must be awaited first!");
26543 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
26544 return nativeResponseValue;
26546 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
26548 export function CommitmentTransaction_clone(orig: number): number {
26549 if(!isWasmInitialized) {
26550 throw new Error("initializeWasm() must be awaited first!");
26552 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
26553 return nativeResponseValue;
26555 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
26557 export function CommitmentTransaction_write(obj: number): number {
26558 if(!isWasmInitialized) {
26559 throw new Error("initializeWasm() must be awaited first!");
26561 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
26562 return nativeResponseValue;
26564 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
26566 export function CommitmentTransaction_read(ser: number): number {
26567 if(!isWasmInitialized) {
26568 throw new Error("initializeWasm() must be awaited first!");
26570 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
26571 return nativeResponseValue;
26573 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26575 export function CommitmentTransaction_commitment_number(this_arg: number): bigint {
26576 if(!isWasmInitialized) {
26577 throw new Error("initializeWasm() must be awaited first!");
26579 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
26580 return nativeResponseValue;
26582 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26584 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: number): bigint {
26585 if(!isWasmInitialized) {
26586 throw new Error("initializeWasm() must be awaited first!");
26588 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
26589 return nativeResponseValue;
26591 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26593 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: number): bigint {
26594 if(!isWasmInitialized) {
26595 throw new Error("initializeWasm() must be awaited first!");
26597 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
26598 return nativeResponseValue;
26600 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26602 export function CommitmentTransaction_feerate_per_kw(this_arg: number): number {
26603 if(!isWasmInitialized) {
26604 throw new Error("initializeWasm() must be awaited first!");
26606 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
26607 return nativeResponseValue;
26609 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26611 export function CommitmentTransaction_trust(this_arg: number): number {
26612 if(!isWasmInitialized) {
26613 throw new Error("initializeWasm() must be awaited first!");
26615 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
26616 return nativeResponseValue;
26618 // 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);
26620 export function CommitmentTransaction_verify(this_arg: number, channel_parameters: number, broadcaster_keys: number, countersignatory_keys: number): number {
26621 if(!isWasmInitialized) {
26622 throw new Error("initializeWasm() must be awaited first!");
26624 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
26625 return nativeResponseValue;
26627 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
26629 export function TrustedCommitmentTransaction_free(this_obj: number): void {
26630 if(!isWasmInitialized) {
26631 throw new Error("initializeWasm() must be awaited first!");
26633 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
26634 // debug statements here
26636 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26638 export function TrustedCommitmentTransaction_txid(this_arg: number): number {
26639 if(!isWasmInitialized) {
26640 throw new Error("initializeWasm() must be awaited first!");
26642 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
26643 return nativeResponseValue;
26645 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26647 export function TrustedCommitmentTransaction_built_transaction(this_arg: number): number {
26648 if(!isWasmInitialized) {
26649 throw new Error("initializeWasm() must be awaited first!");
26651 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
26652 return nativeResponseValue;
26654 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26656 export function TrustedCommitmentTransaction_keys(this_arg: number): number {
26657 if(!isWasmInitialized) {
26658 throw new Error("initializeWasm() must be awaited first!");
26660 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
26661 return nativeResponseValue;
26663 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26665 export function TrustedCommitmentTransaction_opt_anchors(this_arg: number): boolean {
26666 if(!isWasmInitialized) {
26667 throw new Error("initializeWasm() must be awaited first!");
26669 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
26670 return nativeResponseValue;
26672 // 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);
26674 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: number, htlc_base_key: number, channel_parameters: number): number {
26675 if(!isWasmInitialized) {
26676 throw new Error("initializeWasm() must be awaited first!");
26678 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
26679 return nativeResponseValue;
26681 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
26683 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
26684 if(!isWasmInitialized) {
26685 throw new Error("initializeWasm() must be awaited first!");
26687 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
26688 return nativeResponseValue;
26690 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
26692 export function InitFeatures_eq(a: number, b: number): boolean {
26693 if(!isWasmInitialized) {
26694 throw new Error("initializeWasm() must be awaited first!");
26696 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
26697 return nativeResponseValue;
26699 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
26701 export function NodeFeatures_eq(a: number, b: number): boolean {
26702 if(!isWasmInitialized) {
26703 throw new Error("initializeWasm() must be awaited first!");
26705 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
26706 return nativeResponseValue;
26708 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
26710 export function ChannelFeatures_eq(a: number, b: number): boolean {
26711 if(!isWasmInitialized) {
26712 throw new Error("initializeWasm() must be awaited first!");
26714 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
26715 return nativeResponseValue;
26717 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
26719 export function InvoiceFeatures_eq(a: number, b: number): boolean {
26720 if(!isWasmInitialized) {
26721 throw new Error("initializeWasm() must be awaited first!");
26723 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
26724 return nativeResponseValue;
26726 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
26728 export function ChannelTypeFeatures_eq(a: number, b: number): boolean {
26729 if(!isWasmInitialized) {
26730 throw new Error("initializeWasm() must be awaited first!");
26732 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
26733 return nativeResponseValue;
26735 // uintptr_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
26737 export function InitFeatures_clone_ptr(arg: number): number {
26738 if(!isWasmInitialized) {
26739 throw new Error("initializeWasm() must be awaited first!");
26741 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
26742 return nativeResponseValue;
26744 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
26746 export function InitFeatures_clone(orig: number): number {
26747 if(!isWasmInitialized) {
26748 throw new Error("initializeWasm() must be awaited first!");
26750 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
26751 return nativeResponseValue;
26753 // uintptr_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
26755 export function NodeFeatures_clone_ptr(arg: number): number {
26756 if(!isWasmInitialized) {
26757 throw new Error("initializeWasm() must be awaited first!");
26759 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
26760 return nativeResponseValue;
26762 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
26764 export function NodeFeatures_clone(orig: number): number {
26765 if(!isWasmInitialized) {
26766 throw new Error("initializeWasm() must be awaited first!");
26768 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
26769 return nativeResponseValue;
26771 // uintptr_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
26773 export function ChannelFeatures_clone_ptr(arg: number): number {
26774 if(!isWasmInitialized) {
26775 throw new Error("initializeWasm() must be awaited first!");
26777 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
26778 return nativeResponseValue;
26780 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
26782 export function ChannelFeatures_clone(orig: number): number {
26783 if(!isWasmInitialized) {
26784 throw new Error("initializeWasm() must be awaited first!");
26786 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
26787 return nativeResponseValue;
26789 // uintptr_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
26791 export function InvoiceFeatures_clone_ptr(arg: number): number {
26792 if(!isWasmInitialized) {
26793 throw new Error("initializeWasm() must be awaited first!");
26795 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
26796 return nativeResponseValue;
26798 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
26800 export function InvoiceFeatures_clone(orig: number): number {
26801 if(!isWasmInitialized) {
26802 throw new Error("initializeWasm() must be awaited first!");
26804 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
26805 return nativeResponseValue;
26807 // uintptr_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
26809 export function ChannelTypeFeatures_clone_ptr(arg: number): number {
26810 if(!isWasmInitialized) {
26811 throw new Error("initializeWasm() must be awaited first!");
26813 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
26814 return nativeResponseValue;
26816 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
26818 export function ChannelTypeFeatures_clone(orig: number): number {
26819 if(!isWasmInitialized) {
26820 throw new Error("initializeWasm() must be awaited first!");
26822 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
26823 return nativeResponseValue;
26825 // void InitFeatures_free(struct LDKInitFeatures this_obj);
26827 export function InitFeatures_free(this_obj: number): void {
26828 if(!isWasmInitialized) {
26829 throw new Error("initializeWasm() must be awaited first!");
26831 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
26832 // debug statements here
26834 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
26836 export function NodeFeatures_free(this_obj: number): void {
26837 if(!isWasmInitialized) {
26838 throw new Error("initializeWasm() must be awaited first!");
26840 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
26841 // debug statements here
26843 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
26845 export function ChannelFeatures_free(this_obj: number): void {
26846 if(!isWasmInitialized) {
26847 throw new Error("initializeWasm() must be awaited first!");
26849 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
26850 // debug statements here
26852 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
26854 export function InvoiceFeatures_free(this_obj: number): void {
26855 if(!isWasmInitialized) {
26856 throw new Error("initializeWasm() must be awaited first!");
26858 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
26859 // debug statements here
26861 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
26863 export function ChannelTypeFeatures_free(this_obj: number): void {
26864 if(!isWasmInitialized) {
26865 throw new Error("initializeWasm() must be awaited first!");
26867 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
26868 // debug statements here
26870 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
26872 export function InitFeatures_empty(): number {
26873 if(!isWasmInitialized) {
26874 throw new Error("initializeWasm() must be awaited first!");
26876 const nativeResponseValue = wasm.TS_InitFeatures_empty();
26877 return nativeResponseValue;
26879 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
26881 export function InitFeatures_known(): number {
26882 if(!isWasmInitialized) {
26883 throw new Error("initializeWasm() must be awaited first!");
26885 const nativeResponseValue = wasm.TS_InitFeatures_known();
26886 return nativeResponseValue;
26888 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26890 export function InitFeatures_requires_unknown_bits(this_arg: number): boolean {
26891 if(!isWasmInitialized) {
26892 throw new Error("initializeWasm() must be awaited first!");
26894 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
26895 return nativeResponseValue;
26897 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
26899 export function NodeFeatures_empty(): number {
26900 if(!isWasmInitialized) {
26901 throw new Error("initializeWasm() must be awaited first!");
26903 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
26904 return nativeResponseValue;
26906 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
26908 export function NodeFeatures_known(): number {
26909 if(!isWasmInitialized) {
26910 throw new Error("initializeWasm() must be awaited first!");
26912 const nativeResponseValue = wasm.TS_NodeFeatures_known();
26913 return nativeResponseValue;
26915 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
26917 export function NodeFeatures_requires_unknown_bits(this_arg: number): boolean {
26918 if(!isWasmInitialized) {
26919 throw new Error("initializeWasm() must be awaited first!");
26921 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
26922 return nativeResponseValue;
26924 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
26926 export function ChannelFeatures_empty(): number {
26927 if(!isWasmInitialized) {
26928 throw new Error("initializeWasm() must be awaited first!");
26930 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
26931 return nativeResponseValue;
26933 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
26935 export function ChannelFeatures_known(): number {
26936 if(!isWasmInitialized) {
26937 throw new Error("initializeWasm() must be awaited first!");
26939 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
26940 return nativeResponseValue;
26942 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
26944 export function ChannelFeatures_requires_unknown_bits(this_arg: number): boolean {
26945 if(!isWasmInitialized) {
26946 throw new Error("initializeWasm() must be awaited first!");
26948 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
26949 return nativeResponseValue;
26951 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
26953 export function InvoiceFeatures_empty(): number {
26954 if(!isWasmInitialized) {
26955 throw new Error("initializeWasm() must be awaited first!");
26957 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
26958 return nativeResponseValue;
26960 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
26962 export function InvoiceFeatures_known(): number {
26963 if(!isWasmInitialized) {
26964 throw new Error("initializeWasm() must be awaited first!");
26966 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
26967 return nativeResponseValue;
26969 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
26971 export function InvoiceFeatures_requires_unknown_bits(this_arg: number): boolean {
26972 if(!isWasmInitialized) {
26973 throw new Error("initializeWasm() must be awaited first!");
26975 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
26976 return nativeResponseValue;
26978 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
26980 export function ChannelTypeFeatures_empty(): number {
26981 if(!isWasmInitialized) {
26982 throw new Error("initializeWasm() must be awaited first!");
26984 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
26985 return nativeResponseValue;
26987 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
26989 export function ChannelTypeFeatures_known(): number {
26990 if(!isWasmInitialized) {
26991 throw new Error("initializeWasm() must be awaited first!");
26993 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
26994 return nativeResponseValue;
26996 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
26998 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: number): boolean {
26999 if(!isWasmInitialized) {
27000 throw new Error("initializeWasm() must be awaited first!");
27002 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
27003 return nativeResponseValue;
27005 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
27007 export function InitFeatures_write(obj: number): number {
27008 if(!isWasmInitialized) {
27009 throw new Error("initializeWasm() must be awaited first!");
27011 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
27012 return nativeResponseValue;
27014 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
27016 export function InitFeatures_read(ser: number): number {
27017 if(!isWasmInitialized) {
27018 throw new Error("initializeWasm() must be awaited first!");
27020 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
27021 return nativeResponseValue;
27023 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
27025 export function ChannelFeatures_write(obj: number): number {
27026 if(!isWasmInitialized) {
27027 throw new Error("initializeWasm() must be awaited first!");
27029 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
27030 return nativeResponseValue;
27032 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
27034 export function ChannelFeatures_read(ser: number): number {
27035 if(!isWasmInitialized) {
27036 throw new Error("initializeWasm() must be awaited first!");
27038 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
27039 return nativeResponseValue;
27041 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
27043 export function NodeFeatures_write(obj: number): number {
27044 if(!isWasmInitialized) {
27045 throw new Error("initializeWasm() must be awaited first!");
27047 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
27048 return nativeResponseValue;
27050 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
27052 export function NodeFeatures_read(ser: number): number {
27053 if(!isWasmInitialized) {
27054 throw new Error("initializeWasm() must be awaited first!");
27056 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
27057 return nativeResponseValue;
27059 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
27061 export function InvoiceFeatures_write(obj: number): number {
27062 if(!isWasmInitialized) {
27063 throw new Error("initializeWasm() must be awaited first!");
27065 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
27066 return nativeResponseValue;
27068 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
27070 export function InvoiceFeatures_read(ser: number): number {
27071 if(!isWasmInitialized) {
27072 throw new Error("initializeWasm() must be awaited first!");
27074 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
27075 return nativeResponseValue;
27077 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
27079 export function ChannelTypeFeatures_write(obj: number): number {
27080 if(!isWasmInitialized) {
27081 throw new Error("initializeWasm() must be awaited first!");
27083 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
27084 return nativeResponseValue;
27086 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
27088 export function ChannelTypeFeatures_read(ser: number): number {
27089 if(!isWasmInitialized) {
27090 throw new Error("initializeWasm() must be awaited first!");
27092 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
27093 return nativeResponseValue;
27095 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27097 export function InitFeatures_set_data_loss_protect_optional(this_arg: number): void {
27098 if(!isWasmInitialized) {
27099 throw new Error("initializeWasm() must be awaited first!");
27101 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
27102 // debug statements here
27104 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27106 export function InitFeatures_set_data_loss_protect_required(this_arg: number): void {
27107 if(!isWasmInitialized) {
27108 throw new Error("initializeWasm() must be awaited first!");
27110 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
27111 // debug statements here
27113 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27115 export function InitFeatures_supports_data_loss_protect(this_arg: number): boolean {
27116 if(!isWasmInitialized) {
27117 throw new Error("initializeWasm() must be awaited first!");
27119 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
27120 return nativeResponseValue;
27122 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27124 export function NodeFeatures_set_data_loss_protect_optional(this_arg: number): void {
27125 if(!isWasmInitialized) {
27126 throw new Error("initializeWasm() must be awaited first!");
27128 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
27129 // debug statements here
27131 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27133 export function NodeFeatures_set_data_loss_protect_required(this_arg: number): void {
27134 if(!isWasmInitialized) {
27135 throw new Error("initializeWasm() must be awaited first!");
27137 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
27138 // debug statements here
27140 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27142 export function NodeFeatures_supports_data_loss_protect(this_arg: number): boolean {
27143 if(!isWasmInitialized) {
27144 throw new Error("initializeWasm() must be awaited first!");
27146 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
27147 return nativeResponseValue;
27149 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27151 export function InitFeatures_requires_data_loss_protect(this_arg: number): boolean {
27152 if(!isWasmInitialized) {
27153 throw new Error("initializeWasm() must be awaited first!");
27155 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
27156 return nativeResponseValue;
27158 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27160 export function NodeFeatures_requires_data_loss_protect(this_arg: number): boolean {
27161 if(!isWasmInitialized) {
27162 throw new Error("initializeWasm() must be awaited first!");
27164 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
27165 return nativeResponseValue;
27167 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27169 export function InitFeatures_set_initial_routing_sync_optional(this_arg: number): void {
27170 if(!isWasmInitialized) {
27171 throw new Error("initializeWasm() must be awaited first!");
27173 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
27174 // debug statements here
27176 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27178 export function InitFeatures_set_initial_routing_sync_required(this_arg: number): void {
27179 if(!isWasmInitialized) {
27180 throw new Error("initializeWasm() must be awaited first!");
27182 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
27183 // debug statements here
27185 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27187 export function InitFeatures_initial_routing_sync(this_arg: number): boolean {
27188 if(!isWasmInitialized) {
27189 throw new Error("initializeWasm() must be awaited first!");
27191 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
27192 return nativeResponseValue;
27194 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27196 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: number): void {
27197 if(!isWasmInitialized) {
27198 throw new Error("initializeWasm() must be awaited first!");
27200 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
27201 // debug statements here
27203 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27205 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: number): void {
27206 if(!isWasmInitialized) {
27207 throw new Error("initializeWasm() must be awaited first!");
27209 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
27210 // debug statements here
27212 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27214 export function InitFeatures_supports_upfront_shutdown_script(this_arg: number): boolean {
27215 if(!isWasmInitialized) {
27216 throw new Error("initializeWasm() must be awaited first!");
27218 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
27219 return nativeResponseValue;
27221 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27223 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: number): void {
27224 if(!isWasmInitialized) {
27225 throw new Error("initializeWasm() must be awaited first!");
27227 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
27228 // debug statements here
27230 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27232 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: number): void {
27233 if(!isWasmInitialized) {
27234 throw new Error("initializeWasm() must be awaited first!");
27236 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
27237 // debug statements here
27239 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27241 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: number): boolean {
27242 if(!isWasmInitialized) {
27243 throw new Error("initializeWasm() must be awaited first!");
27245 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
27246 return nativeResponseValue;
27248 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27250 export function InitFeatures_requires_upfront_shutdown_script(this_arg: number): boolean {
27251 if(!isWasmInitialized) {
27252 throw new Error("initializeWasm() must be awaited first!");
27254 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
27255 return nativeResponseValue;
27257 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27259 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: number): boolean {
27260 if(!isWasmInitialized) {
27261 throw new Error("initializeWasm() must be awaited first!");
27263 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
27264 return nativeResponseValue;
27266 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27268 export function InitFeatures_set_gossip_queries_optional(this_arg: number): void {
27269 if(!isWasmInitialized) {
27270 throw new Error("initializeWasm() must be awaited first!");
27272 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
27273 // debug statements here
27275 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27277 export function InitFeatures_set_gossip_queries_required(this_arg: number): void {
27278 if(!isWasmInitialized) {
27279 throw new Error("initializeWasm() must be awaited first!");
27281 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
27282 // debug statements here
27284 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27286 export function InitFeatures_supports_gossip_queries(this_arg: number): boolean {
27287 if(!isWasmInitialized) {
27288 throw new Error("initializeWasm() must be awaited first!");
27290 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
27291 return nativeResponseValue;
27293 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27295 export function NodeFeatures_set_gossip_queries_optional(this_arg: number): void {
27296 if(!isWasmInitialized) {
27297 throw new Error("initializeWasm() must be awaited first!");
27299 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
27300 // debug statements here
27302 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27304 export function NodeFeatures_set_gossip_queries_required(this_arg: number): void {
27305 if(!isWasmInitialized) {
27306 throw new Error("initializeWasm() must be awaited first!");
27308 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
27309 // debug statements here
27311 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27313 export function NodeFeatures_supports_gossip_queries(this_arg: number): boolean {
27314 if(!isWasmInitialized) {
27315 throw new Error("initializeWasm() must be awaited first!");
27317 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
27318 return nativeResponseValue;
27320 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27322 export function InitFeatures_requires_gossip_queries(this_arg: number): boolean {
27323 if(!isWasmInitialized) {
27324 throw new Error("initializeWasm() must be awaited first!");
27326 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
27327 return nativeResponseValue;
27329 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27331 export function NodeFeatures_requires_gossip_queries(this_arg: number): boolean {
27332 if(!isWasmInitialized) {
27333 throw new Error("initializeWasm() must be awaited first!");
27335 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
27336 return nativeResponseValue;
27338 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27340 export function InitFeatures_set_variable_length_onion_optional(this_arg: number): void {
27341 if(!isWasmInitialized) {
27342 throw new Error("initializeWasm() must be awaited first!");
27344 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
27345 // debug statements here
27347 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27349 export function InitFeatures_set_variable_length_onion_required(this_arg: number): void {
27350 if(!isWasmInitialized) {
27351 throw new Error("initializeWasm() must be awaited first!");
27353 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
27354 // debug statements here
27356 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27358 export function InitFeatures_supports_variable_length_onion(this_arg: number): boolean {
27359 if(!isWasmInitialized) {
27360 throw new Error("initializeWasm() must be awaited first!");
27362 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
27363 return nativeResponseValue;
27365 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27367 export function NodeFeatures_set_variable_length_onion_optional(this_arg: number): void {
27368 if(!isWasmInitialized) {
27369 throw new Error("initializeWasm() must be awaited first!");
27371 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
27372 // debug statements here
27374 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27376 export function NodeFeatures_set_variable_length_onion_required(this_arg: number): void {
27377 if(!isWasmInitialized) {
27378 throw new Error("initializeWasm() must be awaited first!");
27380 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
27381 // debug statements here
27383 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27385 export function NodeFeatures_supports_variable_length_onion(this_arg: number): boolean {
27386 if(!isWasmInitialized) {
27387 throw new Error("initializeWasm() must be awaited first!");
27389 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
27390 return nativeResponseValue;
27392 // void InvoiceFeatures_set_variable_length_onion_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27394 export function InvoiceFeatures_set_variable_length_onion_optional(this_arg: number): void {
27395 if(!isWasmInitialized) {
27396 throw new Error("initializeWasm() must be awaited first!");
27398 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_optional(this_arg);
27399 // debug statements here
27401 // void InvoiceFeatures_set_variable_length_onion_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27403 export function InvoiceFeatures_set_variable_length_onion_required(this_arg: number): void {
27404 if(!isWasmInitialized) {
27405 throw new Error("initializeWasm() must be awaited first!");
27407 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_required(this_arg);
27408 // debug statements here
27410 // MUST_USE_RES bool InvoiceFeatures_supports_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27412 export function InvoiceFeatures_supports_variable_length_onion(this_arg: number): boolean {
27413 if(!isWasmInitialized) {
27414 throw new Error("initializeWasm() must be awaited first!");
27416 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_variable_length_onion(this_arg);
27417 return nativeResponseValue;
27419 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27421 export function InitFeatures_requires_variable_length_onion(this_arg: number): boolean {
27422 if(!isWasmInitialized) {
27423 throw new Error("initializeWasm() must be awaited first!");
27425 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
27426 return nativeResponseValue;
27428 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27430 export function NodeFeatures_requires_variable_length_onion(this_arg: number): boolean {
27431 if(!isWasmInitialized) {
27432 throw new Error("initializeWasm() must be awaited first!");
27434 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
27435 return nativeResponseValue;
27437 // MUST_USE_RES bool InvoiceFeatures_requires_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27439 export function InvoiceFeatures_requires_variable_length_onion(this_arg: number): boolean {
27440 if(!isWasmInitialized) {
27441 throw new Error("initializeWasm() must be awaited first!");
27443 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_variable_length_onion(this_arg);
27444 return nativeResponseValue;
27446 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27448 export function InitFeatures_set_static_remote_key_optional(this_arg: number): void {
27449 if(!isWasmInitialized) {
27450 throw new Error("initializeWasm() must be awaited first!");
27452 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
27453 // debug statements here
27455 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27457 export function InitFeatures_set_static_remote_key_required(this_arg: number): void {
27458 if(!isWasmInitialized) {
27459 throw new Error("initializeWasm() must be awaited first!");
27461 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
27462 // debug statements here
27464 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27466 export function InitFeatures_supports_static_remote_key(this_arg: number): boolean {
27467 if(!isWasmInitialized) {
27468 throw new Error("initializeWasm() must be awaited first!");
27470 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
27471 return nativeResponseValue;
27473 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27475 export function NodeFeatures_set_static_remote_key_optional(this_arg: number): void {
27476 if(!isWasmInitialized) {
27477 throw new Error("initializeWasm() must be awaited first!");
27479 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
27480 // debug statements here
27482 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27484 export function NodeFeatures_set_static_remote_key_required(this_arg: number): void {
27485 if(!isWasmInitialized) {
27486 throw new Error("initializeWasm() must be awaited first!");
27488 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
27489 // debug statements here
27491 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27493 export function NodeFeatures_supports_static_remote_key(this_arg: number): boolean {
27494 if(!isWasmInitialized) {
27495 throw new Error("initializeWasm() must be awaited first!");
27497 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
27498 return nativeResponseValue;
27500 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27502 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: number): void {
27503 if(!isWasmInitialized) {
27504 throw new Error("initializeWasm() must be awaited first!");
27506 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
27507 // debug statements here
27509 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27511 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: number): void {
27512 if(!isWasmInitialized) {
27513 throw new Error("initializeWasm() must be awaited first!");
27515 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
27516 // debug statements here
27518 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27520 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: number): boolean {
27521 if(!isWasmInitialized) {
27522 throw new Error("initializeWasm() must be awaited first!");
27524 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
27525 return nativeResponseValue;
27527 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27529 export function InitFeatures_requires_static_remote_key(this_arg: number): boolean {
27530 if(!isWasmInitialized) {
27531 throw new Error("initializeWasm() must be awaited first!");
27533 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
27534 return nativeResponseValue;
27536 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27538 export function NodeFeatures_requires_static_remote_key(this_arg: number): boolean {
27539 if(!isWasmInitialized) {
27540 throw new Error("initializeWasm() must be awaited first!");
27542 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
27543 return nativeResponseValue;
27545 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27547 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: number): boolean {
27548 if(!isWasmInitialized) {
27549 throw new Error("initializeWasm() must be awaited first!");
27551 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
27552 return nativeResponseValue;
27554 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27556 export function InitFeatures_set_payment_secret_optional(this_arg: number): void {
27557 if(!isWasmInitialized) {
27558 throw new Error("initializeWasm() must be awaited first!");
27560 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
27561 // debug statements here
27563 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27565 export function InitFeatures_set_payment_secret_required(this_arg: number): void {
27566 if(!isWasmInitialized) {
27567 throw new Error("initializeWasm() must be awaited first!");
27569 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
27570 // debug statements here
27572 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27574 export function InitFeatures_supports_payment_secret(this_arg: number): boolean {
27575 if(!isWasmInitialized) {
27576 throw new Error("initializeWasm() must be awaited first!");
27578 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
27579 return nativeResponseValue;
27581 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27583 export function NodeFeatures_set_payment_secret_optional(this_arg: number): void {
27584 if(!isWasmInitialized) {
27585 throw new Error("initializeWasm() must be awaited first!");
27587 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
27588 // debug statements here
27590 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27592 export function NodeFeatures_set_payment_secret_required(this_arg: number): void {
27593 if(!isWasmInitialized) {
27594 throw new Error("initializeWasm() must be awaited first!");
27596 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
27597 // debug statements here
27599 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27601 export function NodeFeatures_supports_payment_secret(this_arg: number): boolean {
27602 if(!isWasmInitialized) {
27603 throw new Error("initializeWasm() must be awaited first!");
27605 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
27606 return nativeResponseValue;
27608 // void InvoiceFeatures_set_payment_secret_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27610 export function InvoiceFeatures_set_payment_secret_optional(this_arg: number): void {
27611 if(!isWasmInitialized) {
27612 throw new Error("initializeWasm() must be awaited first!");
27614 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_optional(this_arg);
27615 // debug statements here
27617 // void InvoiceFeatures_set_payment_secret_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27619 export function InvoiceFeatures_set_payment_secret_required(this_arg: number): void {
27620 if(!isWasmInitialized) {
27621 throw new Error("initializeWasm() must be awaited first!");
27623 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_required(this_arg);
27624 // debug statements here
27626 // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27628 export function InvoiceFeatures_supports_payment_secret(this_arg: number): boolean {
27629 if(!isWasmInitialized) {
27630 throw new Error("initializeWasm() must be awaited first!");
27632 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_payment_secret(this_arg);
27633 return nativeResponseValue;
27635 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27637 export function InitFeatures_requires_payment_secret(this_arg: number): boolean {
27638 if(!isWasmInitialized) {
27639 throw new Error("initializeWasm() must be awaited first!");
27641 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
27642 return nativeResponseValue;
27644 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27646 export function NodeFeatures_requires_payment_secret(this_arg: number): boolean {
27647 if(!isWasmInitialized) {
27648 throw new Error("initializeWasm() must be awaited first!");
27650 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
27651 return nativeResponseValue;
27653 // MUST_USE_RES bool InvoiceFeatures_requires_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27655 export function InvoiceFeatures_requires_payment_secret(this_arg: number): boolean {
27656 if(!isWasmInitialized) {
27657 throw new Error("initializeWasm() must be awaited first!");
27659 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_payment_secret(this_arg);
27660 return nativeResponseValue;
27662 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27664 export function InitFeatures_set_basic_mpp_optional(this_arg: number): void {
27665 if(!isWasmInitialized) {
27666 throw new Error("initializeWasm() must be awaited first!");
27668 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
27669 // debug statements here
27671 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27673 export function InitFeatures_set_basic_mpp_required(this_arg: number): void {
27674 if(!isWasmInitialized) {
27675 throw new Error("initializeWasm() must be awaited first!");
27677 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
27678 // debug statements here
27680 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27682 export function InitFeatures_supports_basic_mpp(this_arg: number): boolean {
27683 if(!isWasmInitialized) {
27684 throw new Error("initializeWasm() must be awaited first!");
27686 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
27687 return nativeResponseValue;
27689 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27691 export function NodeFeatures_set_basic_mpp_optional(this_arg: number): void {
27692 if(!isWasmInitialized) {
27693 throw new Error("initializeWasm() must be awaited first!");
27695 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
27696 // debug statements here
27698 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27700 export function NodeFeatures_set_basic_mpp_required(this_arg: number): void {
27701 if(!isWasmInitialized) {
27702 throw new Error("initializeWasm() must be awaited first!");
27704 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
27705 // debug statements here
27707 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27709 export function NodeFeatures_supports_basic_mpp(this_arg: number): boolean {
27710 if(!isWasmInitialized) {
27711 throw new Error("initializeWasm() must be awaited first!");
27713 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
27714 return nativeResponseValue;
27716 // void InvoiceFeatures_set_basic_mpp_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27718 export function InvoiceFeatures_set_basic_mpp_optional(this_arg: number): void {
27719 if(!isWasmInitialized) {
27720 throw new Error("initializeWasm() must be awaited first!");
27722 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_optional(this_arg);
27723 // debug statements here
27725 // void InvoiceFeatures_set_basic_mpp_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27727 export function InvoiceFeatures_set_basic_mpp_required(this_arg: number): void {
27728 if(!isWasmInitialized) {
27729 throw new Error("initializeWasm() must be awaited first!");
27731 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_required(this_arg);
27732 // debug statements here
27734 // MUST_USE_RES bool InvoiceFeatures_supports_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27736 export function InvoiceFeatures_supports_basic_mpp(this_arg: number): boolean {
27737 if(!isWasmInitialized) {
27738 throw new Error("initializeWasm() must be awaited first!");
27740 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_basic_mpp(this_arg);
27741 return nativeResponseValue;
27743 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27745 export function InitFeatures_requires_basic_mpp(this_arg: number): boolean {
27746 if(!isWasmInitialized) {
27747 throw new Error("initializeWasm() must be awaited first!");
27749 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
27750 return nativeResponseValue;
27752 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27754 export function NodeFeatures_requires_basic_mpp(this_arg: number): boolean {
27755 if(!isWasmInitialized) {
27756 throw new Error("initializeWasm() must be awaited first!");
27758 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
27759 return nativeResponseValue;
27761 // MUST_USE_RES bool InvoiceFeatures_requires_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27763 export function InvoiceFeatures_requires_basic_mpp(this_arg: number): boolean {
27764 if(!isWasmInitialized) {
27765 throw new Error("initializeWasm() must be awaited first!");
27767 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_basic_mpp(this_arg);
27768 return nativeResponseValue;
27770 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27772 export function InitFeatures_set_wumbo_optional(this_arg: number): void {
27773 if(!isWasmInitialized) {
27774 throw new Error("initializeWasm() must be awaited first!");
27776 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
27777 // debug statements here
27779 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27781 export function InitFeatures_set_wumbo_required(this_arg: number): void {
27782 if(!isWasmInitialized) {
27783 throw new Error("initializeWasm() must be awaited first!");
27785 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
27786 // debug statements here
27788 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27790 export function InitFeatures_supports_wumbo(this_arg: number): boolean {
27791 if(!isWasmInitialized) {
27792 throw new Error("initializeWasm() must be awaited first!");
27794 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
27795 return nativeResponseValue;
27797 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27799 export function NodeFeatures_set_wumbo_optional(this_arg: number): void {
27800 if(!isWasmInitialized) {
27801 throw new Error("initializeWasm() must be awaited first!");
27803 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
27804 // debug statements here
27806 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27808 export function NodeFeatures_set_wumbo_required(this_arg: number): void {
27809 if(!isWasmInitialized) {
27810 throw new Error("initializeWasm() must be awaited first!");
27812 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
27813 // debug statements here
27815 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27817 export function NodeFeatures_supports_wumbo(this_arg: number): boolean {
27818 if(!isWasmInitialized) {
27819 throw new Error("initializeWasm() must be awaited first!");
27821 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
27822 return nativeResponseValue;
27824 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27826 export function InitFeatures_requires_wumbo(this_arg: number): boolean {
27827 if(!isWasmInitialized) {
27828 throw new Error("initializeWasm() must be awaited first!");
27830 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
27831 return nativeResponseValue;
27833 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27835 export function NodeFeatures_requires_wumbo(this_arg: number): boolean {
27836 if(!isWasmInitialized) {
27837 throw new Error("initializeWasm() must be awaited first!");
27839 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
27840 return nativeResponseValue;
27842 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27844 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: number): void {
27845 if(!isWasmInitialized) {
27846 throw new Error("initializeWasm() must be awaited first!");
27848 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
27849 // debug statements here
27851 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27853 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: number): void {
27854 if(!isWasmInitialized) {
27855 throw new Error("initializeWasm() must be awaited first!");
27857 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
27858 // debug statements here
27860 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27862 export function InitFeatures_supports_shutdown_anysegwit(this_arg: number): boolean {
27863 if(!isWasmInitialized) {
27864 throw new Error("initializeWasm() must be awaited first!");
27866 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
27867 return nativeResponseValue;
27869 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27871 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: number): void {
27872 if(!isWasmInitialized) {
27873 throw new Error("initializeWasm() must be awaited first!");
27875 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
27876 // debug statements here
27878 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27880 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: number): void {
27881 if(!isWasmInitialized) {
27882 throw new Error("initializeWasm() must be awaited first!");
27884 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
27885 // debug statements here
27887 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27889 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: number): boolean {
27890 if(!isWasmInitialized) {
27891 throw new Error("initializeWasm() must be awaited first!");
27893 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
27894 return nativeResponseValue;
27896 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27898 export function InitFeatures_requires_shutdown_anysegwit(this_arg: number): boolean {
27899 if(!isWasmInitialized) {
27900 throw new Error("initializeWasm() must be awaited first!");
27902 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
27903 return nativeResponseValue;
27905 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27907 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: number): boolean {
27908 if(!isWasmInitialized) {
27909 throw new Error("initializeWasm() must be awaited first!");
27911 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
27912 return nativeResponseValue;
27914 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27916 export function InitFeatures_set_channel_type_optional(this_arg: number): void {
27917 if(!isWasmInitialized) {
27918 throw new Error("initializeWasm() must be awaited first!");
27920 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
27921 // debug statements here
27923 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27925 export function InitFeatures_set_channel_type_required(this_arg: number): void {
27926 if(!isWasmInitialized) {
27927 throw new Error("initializeWasm() must be awaited first!");
27929 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
27930 // debug statements here
27932 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27934 export function InitFeatures_supports_channel_type(this_arg: number): boolean {
27935 if(!isWasmInitialized) {
27936 throw new Error("initializeWasm() must be awaited first!");
27938 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
27939 return nativeResponseValue;
27941 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27943 export function NodeFeatures_set_channel_type_optional(this_arg: number): void {
27944 if(!isWasmInitialized) {
27945 throw new Error("initializeWasm() must be awaited first!");
27947 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
27948 // debug statements here
27950 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27952 export function NodeFeatures_set_channel_type_required(this_arg: number): void {
27953 if(!isWasmInitialized) {
27954 throw new Error("initializeWasm() must be awaited first!");
27956 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
27957 // debug statements here
27959 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27961 export function NodeFeatures_supports_channel_type(this_arg: number): boolean {
27962 if(!isWasmInitialized) {
27963 throw new Error("initializeWasm() must be awaited first!");
27965 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
27966 return nativeResponseValue;
27968 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27970 export function InitFeatures_requires_channel_type(this_arg: number): boolean {
27971 if(!isWasmInitialized) {
27972 throw new Error("initializeWasm() must be awaited first!");
27974 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
27975 return nativeResponseValue;
27977 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27979 export function NodeFeatures_requires_channel_type(this_arg: number): boolean {
27980 if(!isWasmInitialized) {
27981 throw new Error("initializeWasm() must be awaited first!");
27983 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
27984 return nativeResponseValue;
27986 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27988 export function InitFeatures_set_scid_privacy_optional(this_arg: number): void {
27989 if(!isWasmInitialized) {
27990 throw new Error("initializeWasm() must be awaited first!");
27992 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
27993 // debug statements here
27995 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27997 export function InitFeatures_set_scid_privacy_required(this_arg: number): void {
27998 if(!isWasmInitialized) {
27999 throw new Error("initializeWasm() must be awaited first!");
28001 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
28002 // debug statements here
28004 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28006 export function InitFeatures_supports_scid_privacy(this_arg: number): boolean {
28007 if(!isWasmInitialized) {
28008 throw new Error("initializeWasm() must be awaited first!");
28010 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
28011 return nativeResponseValue;
28013 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28015 export function NodeFeatures_set_scid_privacy_optional(this_arg: number): void {
28016 if(!isWasmInitialized) {
28017 throw new Error("initializeWasm() must be awaited first!");
28019 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
28020 // debug statements here
28022 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28024 export function NodeFeatures_set_scid_privacy_required(this_arg: number): void {
28025 if(!isWasmInitialized) {
28026 throw new Error("initializeWasm() must be awaited first!");
28028 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
28029 // debug statements here
28031 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28033 export function NodeFeatures_supports_scid_privacy(this_arg: number): boolean {
28034 if(!isWasmInitialized) {
28035 throw new Error("initializeWasm() must be awaited first!");
28037 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
28038 return nativeResponseValue;
28040 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28042 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: number): void {
28043 if(!isWasmInitialized) {
28044 throw new Error("initializeWasm() must be awaited first!");
28046 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
28047 // debug statements here
28049 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28051 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: number): void {
28052 if(!isWasmInitialized) {
28053 throw new Error("initializeWasm() must be awaited first!");
28055 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
28056 // debug statements here
28058 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28060 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: number): boolean {
28061 if(!isWasmInitialized) {
28062 throw new Error("initializeWasm() must be awaited first!");
28064 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
28065 return nativeResponseValue;
28067 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28069 export function InitFeatures_requires_scid_privacy(this_arg: number): boolean {
28070 if(!isWasmInitialized) {
28071 throw new Error("initializeWasm() must be awaited first!");
28073 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
28074 return nativeResponseValue;
28076 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28078 export function NodeFeatures_requires_scid_privacy(this_arg: number): boolean {
28079 if(!isWasmInitialized) {
28080 throw new Error("initializeWasm() must be awaited first!");
28082 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
28083 return nativeResponseValue;
28085 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28087 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: number): boolean {
28088 if(!isWasmInitialized) {
28089 throw new Error("initializeWasm() must be awaited first!");
28091 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
28092 return nativeResponseValue;
28094 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28096 export function InitFeatures_set_zero_conf_optional(this_arg: number): void {
28097 if(!isWasmInitialized) {
28098 throw new Error("initializeWasm() must be awaited first!");
28100 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
28101 // debug statements here
28103 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28105 export function InitFeatures_set_zero_conf_required(this_arg: number): void {
28106 if(!isWasmInitialized) {
28107 throw new Error("initializeWasm() must be awaited first!");
28109 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
28110 // debug statements here
28112 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28114 export function InitFeatures_supports_zero_conf(this_arg: number): boolean {
28115 if(!isWasmInitialized) {
28116 throw new Error("initializeWasm() must be awaited first!");
28118 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
28119 return nativeResponseValue;
28121 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28123 export function NodeFeatures_set_zero_conf_optional(this_arg: number): void {
28124 if(!isWasmInitialized) {
28125 throw new Error("initializeWasm() must be awaited first!");
28127 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
28128 // debug statements here
28130 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28132 export function NodeFeatures_set_zero_conf_required(this_arg: number): void {
28133 if(!isWasmInitialized) {
28134 throw new Error("initializeWasm() must be awaited first!");
28136 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
28137 // debug statements here
28139 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28141 export function NodeFeatures_supports_zero_conf(this_arg: number): boolean {
28142 if(!isWasmInitialized) {
28143 throw new Error("initializeWasm() must be awaited first!");
28145 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
28146 return nativeResponseValue;
28148 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28150 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: number): void {
28151 if(!isWasmInitialized) {
28152 throw new Error("initializeWasm() must be awaited first!");
28154 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
28155 // debug statements here
28157 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28159 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: number): void {
28160 if(!isWasmInitialized) {
28161 throw new Error("initializeWasm() must be awaited first!");
28163 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
28164 // debug statements here
28166 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28168 export function ChannelTypeFeatures_supports_zero_conf(this_arg: number): boolean {
28169 if(!isWasmInitialized) {
28170 throw new Error("initializeWasm() must be awaited first!");
28172 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
28173 return nativeResponseValue;
28175 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28177 export function InitFeatures_requires_zero_conf(this_arg: number): boolean {
28178 if(!isWasmInitialized) {
28179 throw new Error("initializeWasm() must be awaited first!");
28181 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
28182 return nativeResponseValue;
28184 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28186 export function NodeFeatures_requires_zero_conf(this_arg: number): boolean {
28187 if(!isWasmInitialized) {
28188 throw new Error("initializeWasm() must be awaited first!");
28190 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
28191 return nativeResponseValue;
28193 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28195 export function ChannelTypeFeatures_requires_zero_conf(this_arg: number): boolean {
28196 if(!isWasmInitialized) {
28197 throw new Error("initializeWasm() must be awaited first!");
28199 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
28200 return nativeResponseValue;
28202 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28204 export function NodeFeatures_set_keysend_optional(this_arg: number): void {
28205 if(!isWasmInitialized) {
28206 throw new Error("initializeWasm() must be awaited first!");
28208 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
28209 // debug statements here
28211 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28213 export function NodeFeatures_set_keysend_required(this_arg: number): void {
28214 if(!isWasmInitialized) {
28215 throw new Error("initializeWasm() must be awaited first!");
28217 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
28218 // debug statements here
28220 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28222 export function NodeFeatures_supports_keysend(this_arg: number): boolean {
28223 if(!isWasmInitialized) {
28224 throw new Error("initializeWasm() must be awaited first!");
28226 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
28227 return nativeResponseValue;
28229 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28231 export function NodeFeatures_requires_keysend(this_arg: number): boolean {
28232 if(!isWasmInitialized) {
28233 throw new Error("initializeWasm() must be awaited first!");
28235 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
28236 return nativeResponseValue;
28238 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
28240 export function ShutdownScript_free(this_obj: number): void {
28241 if(!isWasmInitialized) {
28242 throw new Error("initializeWasm() must be awaited first!");
28244 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
28245 // debug statements here
28247 // uintptr_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
28249 export function ShutdownScript_clone_ptr(arg: number): number {
28250 if(!isWasmInitialized) {
28251 throw new Error("initializeWasm() must be awaited first!");
28253 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
28254 return nativeResponseValue;
28256 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
28258 export function ShutdownScript_clone(orig: number): number {
28259 if(!isWasmInitialized) {
28260 throw new Error("initializeWasm() must be awaited first!");
28262 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
28263 return nativeResponseValue;
28265 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
28267 export function InvalidShutdownScript_free(this_obj: number): void {
28268 if(!isWasmInitialized) {
28269 throw new Error("initializeWasm() must be awaited first!");
28271 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
28272 // debug statements here
28274 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
28276 export function InvalidShutdownScript_get_script(this_ptr: number): number {
28277 if(!isWasmInitialized) {
28278 throw new Error("initializeWasm() must be awaited first!");
28280 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
28281 return nativeResponseValue;
28283 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
28285 export function InvalidShutdownScript_set_script(this_ptr: number, val: number): void {
28286 if(!isWasmInitialized) {
28287 throw new Error("initializeWasm() must be awaited first!");
28289 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
28290 // debug statements here
28292 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
28294 export function InvalidShutdownScript_new(script_arg: number): number {
28295 if(!isWasmInitialized) {
28296 throw new Error("initializeWasm() must be awaited first!");
28298 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
28299 return nativeResponseValue;
28301 // uintptr_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
28303 export function InvalidShutdownScript_clone_ptr(arg: number): number {
28304 if(!isWasmInitialized) {
28305 throw new Error("initializeWasm() must be awaited first!");
28307 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
28308 return nativeResponseValue;
28310 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
28312 export function InvalidShutdownScript_clone(orig: number): number {
28313 if(!isWasmInitialized) {
28314 throw new Error("initializeWasm() must be awaited first!");
28316 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
28317 return nativeResponseValue;
28319 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
28321 export function ShutdownScript_write(obj: number): number {
28322 if(!isWasmInitialized) {
28323 throw new Error("initializeWasm() must be awaited first!");
28325 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
28326 return nativeResponseValue;
28328 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
28330 export function ShutdownScript_read(ser: number): number {
28331 if(!isWasmInitialized) {
28332 throw new Error("initializeWasm() must be awaited first!");
28334 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
28335 return nativeResponseValue;
28337 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
28339 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): number {
28340 if(!isWasmInitialized) {
28341 throw new Error("initializeWasm() must be awaited first!");
28343 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
28344 return nativeResponseValue;
28346 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
28348 export function ShutdownScript_new_p2wsh(script_hash: number): number {
28349 if(!isWasmInitialized) {
28350 throw new Error("initializeWasm() must be awaited first!");
28352 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
28353 return nativeResponseValue;
28355 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
28357 export function ShutdownScript_new_witness_program(version: number, program: number): number {
28358 if(!isWasmInitialized) {
28359 throw new Error("initializeWasm() must be awaited first!");
28361 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
28362 return nativeResponseValue;
28364 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
28366 export function ShutdownScript_into_inner(this_arg: number): number {
28367 if(!isWasmInitialized) {
28368 throw new Error("initializeWasm() must be awaited first!");
28370 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
28371 return nativeResponseValue;
28373 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
28375 export function ShutdownScript_as_legacy_pubkey(this_arg: number): number {
28376 if(!isWasmInitialized) {
28377 throw new Error("initializeWasm() must be awaited first!");
28379 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
28380 return nativeResponseValue;
28382 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
28384 export function ShutdownScript_is_compatible(this_arg: number, features: number): boolean {
28385 if(!isWasmInitialized) {
28386 throw new Error("initializeWasm() must be awaited first!");
28388 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
28389 return nativeResponseValue;
28391 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
28393 export function CustomMessageReader_free(this_ptr: number): void {
28394 if(!isWasmInitialized) {
28395 throw new Error("initializeWasm() must be awaited first!");
28397 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
28398 // debug statements here
28400 // uintptr_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
28402 export function Type_clone_ptr(arg: number): number {
28403 if(!isWasmInitialized) {
28404 throw new Error("initializeWasm() must be awaited first!");
28406 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
28407 return nativeResponseValue;
28409 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
28411 export function Type_clone(orig: number): number {
28412 if(!isWasmInitialized) {
28413 throw new Error("initializeWasm() must be awaited first!");
28415 const nativeResponseValue = wasm.TS_Type_clone(orig);
28416 return nativeResponseValue;
28418 // void Type_free(struct LDKType this_ptr);
28420 export function Type_free(this_ptr: number): void {
28421 if(!isWasmInitialized) {
28422 throw new Error("initializeWasm() must be awaited first!");
28424 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
28425 // debug statements here
28427 // void NodeId_free(struct LDKNodeId this_obj);
28429 export function NodeId_free(this_obj: number): void {
28430 if(!isWasmInitialized) {
28431 throw new Error("initializeWasm() must be awaited first!");
28433 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
28434 // debug statements here
28436 // uintptr_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
28438 export function NodeId_clone_ptr(arg: number): number {
28439 if(!isWasmInitialized) {
28440 throw new Error("initializeWasm() must be awaited first!");
28442 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
28443 return nativeResponseValue;
28445 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
28447 export function NodeId_clone(orig: number): number {
28448 if(!isWasmInitialized) {
28449 throw new Error("initializeWasm() must be awaited first!");
28451 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
28452 return nativeResponseValue;
28454 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
28456 export function NodeId_from_pubkey(pubkey: number): number {
28457 if(!isWasmInitialized) {
28458 throw new Error("initializeWasm() must be awaited first!");
28460 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
28461 return nativeResponseValue;
28463 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
28465 export function NodeId_as_slice(this_arg: number): number {
28466 if(!isWasmInitialized) {
28467 throw new Error("initializeWasm() must be awaited first!");
28469 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
28470 return nativeResponseValue;
28472 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
28474 export function NodeId_hash(o: number): bigint {
28475 if(!isWasmInitialized) {
28476 throw new Error("initializeWasm() must be awaited first!");
28478 const nativeResponseValue = wasm.TS_NodeId_hash(o);
28479 return nativeResponseValue;
28481 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
28483 export function NodeId_write(obj: number): number {
28484 if(!isWasmInitialized) {
28485 throw new Error("initializeWasm() must be awaited first!");
28487 const nativeResponseValue = wasm.TS_NodeId_write(obj);
28488 return nativeResponseValue;
28490 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
28492 export function NodeId_read(ser: number): number {
28493 if(!isWasmInitialized) {
28494 throw new Error("initializeWasm() must be awaited first!");
28496 const nativeResponseValue = wasm.TS_NodeId_read(ser);
28497 return nativeResponseValue;
28499 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
28501 export function NetworkGraph_free(this_obj: number): void {
28502 if(!isWasmInitialized) {
28503 throw new Error("initializeWasm() must be awaited first!");
28505 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
28506 // debug statements here
28508 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
28510 export function ReadOnlyNetworkGraph_free(this_obj: number): void {
28511 if(!isWasmInitialized) {
28512 throw new Error("initializeWasm() must be awaited first!");
28514 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
28515 // debug statements here
28517 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
28519 export function NetworkUpdate_free(this_ptr: number): void {
28520 if(!isWasmInitialized) {
28521 throw new Error("initializeWasm() must be awaited first!");
28523 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
28524 // debug statements here
28526 // uintptr_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
28528 export function NetworkUpdate_clone_ptr(arg: number): number {
28529 if(!isWasmInitialized) {
28530 throw new Error("initializeWasm() must be awaited first!");
28532 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
28533 return nativeResponseValue;
28535 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
28537 export function NetworkUpdate_clone(orig: number): number {
28538 if(!isWasmInitialized) {
28539 throw new Error("initializeWasm() must be awaited first!");
28541 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
28542 return nativeResponseValue;
28544 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
28546 export function NetworkUpdate_channel_update_message(msg: number): number {
28547 if(!isWasmInitialized) {
28548 throw new Error("initializeWasm() must be awaited first!");
28550 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
28551 return nativeResponseValue;
28553 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
28555 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): number {
28556 if(!isWasmInitialized) {
28557 throw new Error("initializeWasm() must be awaited first!");
28559 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
28560 return nativeResponseValue;
28562 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
28564 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): number {
28565 if(!isWasmInitialized) {
28566 throw new Error("initializeWasm() must be awaited first!");
28568 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
28569 return nativeResponseValue;
28571 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
28573 export function NetworkUpdate_write(obj: number): number {
28574 if(!isWasmInitialized) {
28575 throw new Error("initializeWasm() must be awaited first!");
28577 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
28578 return nativeResponseValue;
28580 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
28582 export function NetworkUpdate_read(ser: number): number {
28583 if(!isWasmInitialized) {
28584 throw new Error("initializeWasm() must be awaited first!");
28586 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
28587 return nativeResponseValue;
28589 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
28591 export function P2PGossipSync_free(this_obj: number): void {
28592 if(!isWasmInitialized) {
28593 throw new Error("initializeWasm() must be awaited first!");
28595 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
28596 // debug statements here
28598 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
28600 export function P2PGossipSync_new(network_graph: number, chain_access: number, logger: number): number {
28601 if(!isWasmInitialized) {
28602 throw new Error("initializeWasm() must be awaited first!");
28604 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, chain_access, logger);
28605 return nativeResponseValue;
28607 // void P2PGossipSync_add_chain_access(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
28609 export function P2PGossipSync_add_chain_access(this_arg: number, chain_access: number): void {
28610 if(!isWasmInitialized) {
28611 throw new Error("initializeWasm() must be awaited first!");
28613 const nativeResponseValue = wasm.TS_P2PGossipSync_add_chain_access(this_arg, chain_access);
28614 // debug statements here
28616 // struct LDKEventHandler NetworkGraph_as_EventHandler(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
28618 export function NetworkGraph_as_EventHandler(this_arg: number): number {
28619 if(!isWasmInitialized) {
28620 throw new Error("initializeWasm() must be awaited first!");
28622 const nativeResponseValue = wasm.TS_NetworkGraph_as_EventHandler(this_arg);
28623 return nativeResponseValue;
28625 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
28627 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: number): number {
28628 if(!isWasmInitialized) {
28629 throw new Error("initializeWasm() must be awaited first!");
28631 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
28632 return nativeResponseValue;
28634 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
28636 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: number): number {
28637 if(!isWasmInitialized) {
28638 throw new Error("initializeWasm() must be awaited first!");
28640 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
28641 return nativeResponseValue;
28643 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
28645 export function ChannelUpdateInfo_free(this_obj: number): void {
28646 if(!isWasmInitialized) {
28647 throw new Error("initializeWasm() must be awaited first!");
28649 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
28650 // debug statements here
28652 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28654 export function ChannelUpdateInfo_get_last_update(this_ptr: number): number {
28655 if(!isWasmInitialized) {
28656 throw new Error("initializeWasm() must be awaited first!");
28658 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
28659 return nativeResponseValue;
28661 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
28663 export function ChannelUpdateInfo_set_last_update(this_ptr: number, val: number): void {
28664 if(!isWasmInitialized) {
28665 throw new Error("initializeWasm() must be awaited first!");
28667 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
28668 // debug statements here
28670 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28672 export function ChannelUpdateInfo_get_enabled(this_ptr: number): boolean {
28673 if(!isWasmInitialized) {
28674 throw new Error("initializeWasm() must be awaited first!");
28676 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
28677 return nativeResponseValue;
28679 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
28681 export function ChannelUpdateInfo_set_enabled(this_ptr: number, val: boolean): void {
28682 if(!isWasmInitialized) {
28683 throw new Error("initializeWasm() must be awaited first!");
28685 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
28686 // debug statements here
28688 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28690 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: number): number {
28691 if(!isWasmInitialized) {
28692 throw new Error("initializeWasm() must be awaited first!");
28694 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
28695 return nativeResponseValue;
28697 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
28699 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
28700 if(!isWasmInitialized) {
28701 throw new Error("initializeWasm() must be awaited first!");
28703 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
28704 // debug statements here
28706 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28708 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: number): bigint {
28709 if(!isWasmInitialized) {
28710 throw new Error("initializeWasm() must be awaited first!");
28712 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
28713 return nativeResponseValue;
28715 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
28717 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
28718 if(!isWasmInitialized) {
28719 throw new Error("initializeWasm() must be awaited first!");
28721 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
28722 // debug statements here
28724 // struct LDKCOption_u64Z ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28726 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: number): number {
28727 if(!isWasmInitialized) {
28728 throw new Error("initializeWasm() must be awaited first!");
28730 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
28731 return nativeResponseValue;
28733 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28735 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: number, val: number): void {
28736 if(!isWasmInitialized) {
28737 throw new Error("initializeWasm() must be awaited first!");
28739 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
28740 // debug statements here
28742 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28744 export function ChannelUpdateInfo_get_fees(this_ptr: number): number {
28745 if(!isWasmInitialized) {
28746 throw new Error("initializeWasm() must be awaited first!");
28748 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
28749 return nativeResponseValue;
28751 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
28753 export function ChannelUpdateInfo_set_fees(this_ptr: number, val: number): void {
28754 if(!isWasmInitialized) {
28755 throw new Error("initializeWasm() must be awaited first!");
28757 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
28758 // debug statements here
28760 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28762 export function ChannelUpdateInfo_get_last_update_message(this_ptr: number): number {
28763 if(!isWasmInitialized) {
28764 throw new Error("initializeWasm() must be awaited first!");
28766 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
28767 return nativeResponseValue;
28769 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
28771 export function ChannelUpdateInfo_set_last_update_message(this_ptr: number, val: number): void {
28772 if(!isWasmInitialized) {
28773 throw new Error("initializeWasm() must be awaited first!");
28775 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
28776 // debug statements here
28778 // 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, struct LDKCOption_u64Z htlc_maximum_msat_arg, struct LDKRoutingFees fees_arg, struct LDKChannelUpdate last_update_message_arg);
28780 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: number, fees_arg: number, last_update_message_arg: number): number {
28781 if(!isWasmInitialized) {
28782 throw new Error("initializeWasm() must be awaited first!");
28784 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);
28785 return nativeResponseValue;
28787 // uintptr_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
28789 export function ChannelUpdateInfo_clone_ptr(arg: number): number {
28790 if(!isWasmInitialized) {
28791 throw new Error("initializeWasm() must be awaited first!");
28793 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
28794 return nativeResponseValue;
28796 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
28798 export function ChannelUpdateInfo_clone(orig: number): number {
28799 if(!isWasmInitialized) {
28800 throw new Error("initializeWasm() must be awaited first!");
28802 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
28803 return nativeResponseValue;
28805 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
28807 export function ChannelUpdateInfo_write(obj: number): number {
28808 if(!isWasmInitialized) {
28809 throw new Error("initializeWasm() must be awaited first!");
28811 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
28812 return nativeResponseValue;
28814 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
28816 export function ChannelUpdateInfo_read(ser: number): number {
28817 if(!isWasmInitialized) {
28818 throw new Error("initializeWasm() must be awaited first!");
28820 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
28821 return nativeResponseValue;
28823 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
28825 export function ChannelInfo_free(this_obj: number): void {
28826 if(!isWasmInitialized) {
28827 throw new Error("initializeWasm() must be awaited first!");
28829 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
28830 // debug statements here
28832 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28834 export function ChannelInfo_get_features(this_ptr: number): number {
28835 if(!isWasmInitialized) {
28836 throw new Error("initializeWasm() must be awaited first!");
28838 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
28839 return nativeResponseValue;
28841 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
28843 export function ChannelInfo_set_features(this_ptr: number, val: number): void {
28844 if(!isWasmInitialized) {
28845 throw new Error("initializeWasm() must be awaited first!");
28847 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
28848 // debug statements here
28850 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28852 export function ChannelInfo_get_node_one(this_ptr: number): number {
28853 if(!isWasmInitialized) {
28854 throw new Error("initializeWasm() must be awaited first!");
28856 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
28857 return nativeResponseValue;
28859 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
28861 export function ChannelInfo_set_node_one(this_ptr: number, val: number): void {
28862 if(!isWasmInitialized) {
28863 throw new Error("initializeWasm() must be awaited first!");
28865 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
28866 // debug statements here
28868 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28870 export function ChannelInfo_get_one_to_two(this_ptr: number): number {
28871 if(!isWasmInitialized) {
28872 throw new Error("initializeWasm() must be awaited first!");
28874 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
28875 return nativeResponseValue;
28877 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
28879 export function ChannelInfo_set_one_to_two(this_ptr: number, val: number): void {
28880 if(!isWasmInitialized) {
28881 throw new Error("initializeWasm() must be awaited first!");
28883 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
28884 // debug statements here
28886 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28888 export function ChannelInfo_get_node_two(this_ptr: number): number {
28889 if(!isWasmInitialized) {
28890 throw new Error("initializeWasm() must be awaited first!");
28892 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
28893 return nativeResponseValue;
28895 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
28897 export function ChannelInfo_set_node_two(this_ptr: number, val: number): void {
28898 if(!isWasmInitialized) {
28899 throw new Error("initializeWasm() must be awaited first!");
28901 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
28902 // debug statements here
28904 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28906 export function ChannelInfo_get_two_to_one(this_ptr: number): number {
28907 if(!isWasmInitialized) {
28908 throw new Error("initializeWasm() must be awaited first!");
28910 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
28911 return nativeResponseValue;
28913 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
28915 export function ChannelInfo_set_two_to_one(this_ptr: number, val: number): void {
28916 if(!isWasmInitialized) {
28917 throw new Error("initializeWasm() must be awaited first!");
28919 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
28920 // debug statements here
28922 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28924 export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
28925 if(!isWasmInitialized) {
28926 throw new Error("initializeWasm() must be awaited first!");
28928 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
28929 return nativeResponseValue;
28931 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28933 export function ChannelInfo_set_capacity_sats(this_ptr: number, val: number): void {
28934 if(!isWasmInitialized) {
28935 throw new Error("initializeWasm() must be awaited first!");
28937 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
28938 // debug statements here
28940 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28942 export function ChannelInfo_get_announcement_message(this_ptr: number): number {
28943 if(!isWasmInitialized) {
28944 throw new Error("initializeWasm() must be awaited first!");
28946 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
28947 return nativeResponseValue;
28949 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
28951 export function ChannelInfo_set_announcement_message(this_ptr: number, val: number): void {
28952 if(!isWasmInitialized) {
28953 throw new Error("initializeWasm() must be awaited first!");
28955 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
28956 // debug statements here
28958 // uintptr_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
28960 export function ChannelInfo_clone_ptr(arg: number): number {
28961 if(!isWasmInitialized) {
28962 throw new Error("initializeWasm() must be awaited first!");
28964 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
28965 return nativeResponseValue;
28967 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
28969 export function ChannelInfo_clone(orig: number): number {
28970 if(!isWasmInitialized) {
28971 throw new Error("initializeWasm() must be awaited first!");
28973 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
28974 return nativeResponseValue;
28976 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
28978 export function ChannelInfo_get_directional_info(this_arg: number, channel_flags: number): number {
28979 if(!isWasmInitialized) {
28980 throw new Error("initializeWasm() must be awaited first!");
28982 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
28983 return nativeResponseValue;
28985 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
28987 export function ChannelInfo_write(obj: number): number {
28988 if(!isWasmInitialized) {
28989 throw new Error("initializeWasm() must be awaited first!");
28991 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
28992 return nativeResponseValue;
28994 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
28996 export function ChannelInfo_read(ser: number): number {
28997 if(!isWasmInitialized) {
28998 throw new Error("initializeWasm() must be awaited first!");
29000 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
29001 return nativeResponseValue;
29003 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
29005 export function DirectedChannelInfo_free(this_obj: number): void {
29006 if(!isWasmInitialized) {
29007 throw new Error("initializeWasm() must be awaited first!");
29009 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
29010 // debug statements here
29012 // uintptr_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
29014 export function DirectedChannelInfo_clone_ptr(arg: number): number {
29015 if(!isWasmInitialized) {
29016 throw new Error("initializeWasm() must be awaited first!");
29018 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
29019 return nativeResponseValue;
29021 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
29023 export function DirectedChannelInfo_clone(orig: number): number {
29024 if(!isWasmInitialized) {
29025 throw new Error("initializeWasm() must be awaited first!");
29027 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
29028 return nativeResponseValue;
29030 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29032 export function DirectedChannelInfo_channel(this_arg: number): number {
29033 if(!isWasmInitialized) {
29034 throw new Error("initializeWasm() must be awaited first!");
29036 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
29037 return nativeResponseValue;
29039 // MUST_USE_RES struct LDKChannelUpdateInfo DirectedChannelInfo_direction(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29041 export function DirectedChannelInfo_direction(this_arg: number): number {
29042 if(!isWasmInitialized) {
29043 throw new Error("initializeWasm() must be awaited first!");
29045 const nativeResponseValue = wasm.TS_DirectedChannelInfo_direction(this_arg);
29046 return nativeResponseValue;
29048 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29050 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: number): bigint {
29051 if(!isWasmInitialized) {
29052 throw new Error("initializeWasm() must be awaited first!");
29054 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
29055 return nativeResponseValue;
29057 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29059 export function DirectedChannelInfo_effective_capacity(this_arg: number): number {
29060 if(!isWasmInitialized) {
29061 throw new Error("initializeWasm() must be awaited first!");
29063 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
29064 return nativeResponseValue;
29066 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
29068 export function EffectiveCapacity_free(this_ptr: number): void {
29069 if(!isWasmInitialized) {
29070 throw new Error("initializeWasm() must be awaited first!");
29072 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
29073 // debug statements here
29075 // uintptr_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
29077 export function EffectiveCapacity_clone_ptr(arg: number): number {
29078 if(!isWasmInitialized) {
29079 throw new Error("initializeWasm() must be awaited first!");
29081 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
29082 return nativeResponseValue;
29084 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
29086 export function EffectiveCapacity_clone(orig: number): number {
29087 if(!isWasmInitialized) {
29088 throw new Error("initializeWasm() must be awaited first!");
29090 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
29091 return nativeResponseValue;
29093 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
29095 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): number {
29096 if(!isWasmInitialized) {
29097 throw new Error("initializeWasm() must be awaited first!");
29099 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
29100 return nativeResponseValue;
29102 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
29104 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): number {
29105 if(!isWasmInitialized) {
29106 throw new Error("initializeWasm() must be awaited first!");
29108 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
29109 return nativeResponseValue;
29111 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, struct LDKCOption_u64Z htlc_maximum_msat);
29113 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: number): number {
29114 if(!isWasmInitialized) {
29115 throw new Error("initializeWasm() must be awaited first!");
29117 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
29118 return nativeResponseValue;
29120 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
29122 export function EffectiveCapacity_infinite(): number {
29123 if(!isWasmInitialized) {
29124 throw new Error("initializeWasm() must be awaited first!");
29126 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
29127 return nativeResponseValue;
29129 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
29131 export function EffectiveCapacity_unknown(): number {
29132 if(!isWasmInitialized) {
29133 throw new Error("initializeWasm() must be awaited first!");
29135 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
29136 return nativeResponseValue;
29138 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
29140 export function EffectiveCapacity_as_msat(this_arg: number): bigint {
29141 if(!isWasmInitialized) {
29142 throw new Error("initializeWasm() must be awaited first!");
29144 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
29145 return nativeResponseValue;
29147 // void RoutingFees_free(struct LDKRoutingFees this_obj);
29149 export function RoutingFees_free(this_obj: number): void {
29150 if(!isWasmInitialized) {
29151 throw new Error("initializeWasm() must be awaited first!");
29153 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
29154 // debug statements here
29156 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
29158 export function RoutingFees_get_base_msat(this_ptr: number): number {
29159 if(!isWasmInitialized) {
29160 throw new Error("initializeWasm() must be awaited first!");
29162 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
29163 return nativeResponseValue;
29165 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
29167 export function RoutingFees_set_base_msat(this_ptr: number, val: number): void {
29168 if(!isWasmInitialized) {
29169 throw new Error("initializeWasm() must be awaited first!");
29171 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
29172 // debug statements here
29174 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
29176 export function RoutingFees_get_proportional_millionths(this_ptr: number): number {
29177 if(!isWasmInitialized) {
29178 throw new Error("initializeWasm() must be awaited first!");
29180 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
29181 return nativeResponseValue;
29183 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
29185 export function RoutingFees_set_proportional_millionths(this_ptr: number, val: number): void {
29186 if(!isWasmInitialized) {
29187 throw new Error("initializeWasm() must be awaited first!");
29189 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
29190 // debug statements here
29192 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
29194 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): number {
29195 if(!isWasmInitialized) {
29196 throw new Error("initializeWasm() must be awaited first!");
29198 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
29199 return nativeResponseValue;
29201 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
29203 export function RoutingFees_eq(a: number, b: number): boolean {
29204 if(!isWasmInitialized) {
29205 throw new Error("initializeWasm() must be awaited first!");
29207 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
29208 return nativeResponseValue;
29210 // uintptr_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
29212 export function RoutingFees_clone_ptr(arg: number): number {
29213 if(!isWasmInitialized) {
29214 throw new Error("initializeWasm() must be awaited first!");
29216 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
29217 return nativeResponseValue;
29219 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
29221 export function RoutingFees_clone(orig: number): number {
29222 if(!isWasmInitialized) {
29223 throw new Error("initializeWasm() must be awaited first!");
29225 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
29226 return nativeResponseValue;
29228 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
29230 export function RoutingFees_hash(o: number): bigint {
29231 if(!isWasmInitialized) {
29232 throw new Error("initializeWasm() must be awaited first!");
29234 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
29235 return nativeResponseValue;
29237 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
29239 export function RoutingFees_write(obj: number): number {
29240 if(!isWasmInitialized) {
29241 throw new Error("initializeWasm() must be awaited first!");
29243 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
29244 return nativeResponseValue;
29246 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
29248 export function RoutingFees_read(ser: number): number {
29249 if(!isWasmInitialized) {
29250 throw new Error("initializeWasm() must be awaited first!");
29252 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
29253 return nativeResponseValue;
29255 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
29257 export function NodeAnnouncementInfo_free(this_obj: number): void {
29258 if(!isWasmInitialized) {
29259 throw new Error("initializeWasm() must be awaited first!");
29261 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
29262 // debug statements here
29264 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29266 export function NodeAnnouncementInfo_get_features(this_ptr: number): number {
29267 if(!isWasmInitialized) {
29268 throw new Error("initializeWasm() must be awaited first!");
29270 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
29271 return nativeResponseValue;
29273 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
29275 export function NodeAnnouncementInfo_set_features(this_ptr: number, val: number): void {
29276 if(!isWasmInitialized) {
29277 throw new Error("initializeWasm() must be awaited first!");
29279 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
29280 // debug statements here
29282 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29284 export function NodeAnnouncementInfo_get_last_update(this_ptr: number): number {
29285 if(!isWasmInitialized) {
29286 throw new Error("initializeWasm() must be awaited first!");
29288 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
29289 return nativeResponseValue;
29291 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
29293 export function NodeAnnouncementInfo_set_last_update(this_ptr: number, val: number): void {
29294 if(!isWasmInitialized) {
29295 throw new Error("initializeWasm() must be awaited first!");
29297 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
29298 // debug statements here
29300 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
29302 export function NodeAnnouncementInfo_get_rgb(this_ptr: number): number {
29303 if(!isWasmInitialized) {
29304 throw new Error("initializeWasm() must be awaited first!");
29306 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
29307 return nativeResponseValue;
29309 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
29311 export function NodeAnnouncementInfo_set_rgb(this_ptr: number, val: number): void {
29312 if(!isWasmInitialized) {
29313 throw new Error("initializeWasm() must be awaited first!");
29315 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
29316 // debug statements here
29318 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29320 export function NodeAnnouncementInfo_get_alias(this_ptr: number): number {
29321 if(!isWasmInitialized) {
29322 throw new Error("initializeWasm() must be awaited first!");
29324 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
29325 return nativeResponseValue;
29327 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
29329 export function NodeAnnouncementInfo_set_alias(this_ptr: number, val: number): void {
29330 if(!isWasmInitialized) {
29331 throw new Error("initializeWasm() must be awaited first!");
29333 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
29334 // debug statements here
29336 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
29338 export function NodeAnnouncementInfo_set_addresses(this_ptr: number, val: number): void {
29339 if(!isWasmInitialized) {
29340 throw new Error("initializeWasm() must be awaited first!");
29342 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
29343 // debug statements here
29345 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29347 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: number): number {
29348 if(!isWasmInitialized) {
29349 throw new Error("initializeWasm() must be awaited first!");
29351 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
29352 return nativeResponseValue;
29354 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
29356 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: number, val: number): void {
29357 if(!isWasmInitialized) {
29358 throw new Error("initializeWasm() must be awaited first!");
29360 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
29361 // debug statements here
29363 // 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);
29365 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 {
29366 if(!isWasmInitialized) {
29367 throw new Error("initializeWasm() must be awaited first!");
29369 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
29370 return nativeResponseValue;
29372 // uintptr_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
29374 export function NodeAnnouncementInfo_clone_ptr(arg: number): number {
29375 if(!isWasmInitialized) {
29376 throw new Error("initializeWasm() must be awaited first!");
29378 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
29379 return nativeResponseValue;
29381 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
29383 export function NodeAnnouncementInfo_clone(orig: number): number {
29384 if(!isWasmInitialized) {
29385 throw new Error("initializeWasm() must be awaited first!");
29387 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
29388 return nativeResponseValue;
29390 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
29392 export function NodeAnnouncementInfo_write(obj: number): number {
29393 if(!isWasmInitialized) {
29394 throw new Error("initializeWasm() must be awaited first!");
29396 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
29397 return nativeResponseValue;
29399 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
29401 export function NodeAnnouncementInfo_read(ser: number): number {
29402 if(!isWasmInitialized) {
29403 throw new Error("initializeWasm() must be awaited first!");
29405 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
29406 return nativeResponseValue;
29408 // void NodeAlias_free(struct LDKNodeAlias this_obj);
29410 export function NodeAlias_free(this_obj: number): void {
29411 if(!isWasmInitialized) {
29412 throw new Error("initializeWasm() must be awaited first!");
29414 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
29415 // debug statements here
29417 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
29419 export function NodeAlias_get_a(this_ptr: number): number {
29420 if(!isWasmInitialized) {
29421 throw new Error("initializeWasm() must be awaited first!");
29423 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
29424 return nativeResponseValue;
29426 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29428 export function NodeAlias_set_a(this_ptr: number, val: number): void {
29429 if(!isWasmInitialized) {
29430 throw new Error("initializeWasm() must be awaited first!");
29432 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
29433 // debug statements here
29435 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
29437 export function NodeAlias_new(a_arg: number): number {
29438 if(!isWasmInitialized) {
29439 throw new Error("initializeWasm() must be awaited first!");
29441 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
29442 return nativeResponseValue;
29444 // uintptr_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
29446 export function NodeAlias_clone_ptr(arg: number): number {
29447 if(!isWasmInitialized) {
29448 throw new Error("initializeWasm() must be awaited first!");
29450 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
29451 return nativeResponseValue;
29453 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
29455 export function NodeAlias_clone(orig: number): number {
29456 if(!isWasmInitialized) {
29457 throw new Error("initializeWasm() must be awaited first!");
29459 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
29460 return nativeResponseValue;
29462 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
29464 export function NodeAlias_write(obj: number): number {
29465 if(!isWasmInitialized) {
29466 throw new Error("initializeWasm() must be awaited first!");
29468 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
29469 return nativeResponseValue;
29471 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
29473 export function NodeAlias_read(ser: number): number {
29474 if(!isWasmInitialized) {
29475 throw new Error("initializeWasm() must be awaited first!");
29477 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
29478 return nativeResponseValue;
29480 // void NodeInfo_free(struct LDKNodeInfo this_obj);
29482 export function NodeInfo_free(this_obj: number): void {
29483 if(!isWasmInitialized) {
29484 throw new Error("initializeWasm() must be awaited first!");
29486 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
29487 // debug statements here
29489 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
29491 export function NodeInfo_set_channels(this_ptr: number, val: number): void {
29492 if(!isWasmInitialized) {
29493 throw new Error("initializeWasm() must be awaited first!");
29495 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
29496 // debug statements here
29498 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
29500 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: number): number {
29501 if(!isWasmInitialized) {
29502 throw new Error("initializeWasm() must be awaited first!");
29504 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
29505 return nativeResponseValue;
29507 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
29509 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: number, val: number): void {
29510 if(!isWasmInitialized) {
29511 throw new Error("initializeWasm() must be awaited first!");
29513 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
29514 // debug statements here
29516 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
29518 export function NodeInfo_get_announcement_info(this_ptr: number): number {
29519 if(!isWasmInitialized) {
29520 throw new Error("initializeWasm() must be awaited first!");
29522 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
29523 return nativeResponseValue;
29525 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
29527 export function NodeInfo_set_announcement_info(this_ptr: number, val: number): void {
29528 if(!isWasmInitialized) {
29529 throw new Error("initializeWasm() must be awaited first!");
29531 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
29532 // debug statements here
29534 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
29536 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: number, announcement_info_arg: number): number {
29537 if(!isWasmInitialized) {
29538 throw new Error("initializeWasm() must be awaited first!");
29540 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
29541 return nativeResponseValue;
29543 // uintptr_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
29545 export function NodeInfo_clone_ptr(arg: number): number {
29546 if(!isWasmInitialized) {
29547 throw new Error("initializeWasm() must be awaited first!");
29549 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
29550 return nativeResponseValue;
29552 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
29554 export function NodeInfo_clone(orig: number): number {
29555 if(!isWasmInitialized) {
29556 throw new Error("initializeWasm() must be awaited first!");
29558 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
29559 return nativeResponseValue;
29561 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
29563 export function NodeInfo_write(obj: number): number {
29564 if(!isWasmInitialized) {
29565 throw new Error("initializeWasm() must be awaited first!");
29567 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
29568 return nativeResponseValue;
29570 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
29572 export function NodeInfo_read(ser: number): number {
29573 if(!isWasmInitialized) {
29574 throw new Error("initializeWasm() must be awaited first!");
29576 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
29577 return nativeResponseValue;
29579 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
29581 export function NetworkGraph_write(obj: number): number {
29582 if(!isWasmInitialized) {
29583 throw new Error("initializeWasm() must be awaited first!");
29585 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
29586 return nativeResponseValue;
29588 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
29590 export function NetworkGraph_read(ser: number, arg: number): number {
29591 if(!isWasmInitialized) {
29592 throw new Error("initializeWasm() must be awaited first!");
29594 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
29595 return nativeResponseValue;
29597 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKLogger logger);
29599 export function NetworkGraph_new(genesis_hash: number, logger: number): number {
29600 if(!isWasmInitialized) {
29601 throw new Error("initializeWasm() must be awaited first!");
29603 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash, logger);
29604 return nativeResponseValue;
29606 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
29608 export function NetworkGraph_read_only(this_arg: number): number {
29609 if(!isWasmInitialized) {
29610 throw new Error("initializeWasm() must be awaited first!");
29612 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
29613 return nativeResponseValue;
29615 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
29617 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: number): number {
29618 if(!isWasmInitialized) {
29619 throw new Error("initializeWasm() must be awaited first!");
29621 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
29622 return nativeResponseValue;
29624 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
29626 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: number, last_rapid_gossip_sync_timestamp: number): void {
29627 if(!isWasmInitialized) {
29628 throw new Error("initializeWasm() must be awaited first!");
29630 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
29631 // debug statements here
29633 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
29635 export function NetworkGraph_update_node_from_announcement(this_arg: number, msg: number): number {
29636 if(!isWasmInitialized) {
29637 throw new Error("initializeWasm() must be awaited first!");
29639 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
29640 return nativeResponseValue;
29642 // 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);
29644 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: number, msg: number): number {
29645 if(!isWasmInitialized) {
29646 throw new Error("initializeWasm() must be awaited first!");
29648 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
29649 return nativeResponseValue;
29651 // 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);
29653 export function NetworkGraph_update_channel_from_announcement(this_arg: number, msg: number, chain_access: number): number {
29654 if(!isWasmInitialized) {
29655 throw new Error("initializeWasm() must be awaited first!");
29657 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
29658 return nativeResponseValue;
29660 // 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);
29662 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: number, msg: number, chain_access: number): number {
29663 if(!isWasmInitialized) {
29664 throw new Error("initializeWasm() must be awaited first!");
29666 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
29667 return nativeResponseValue;
29669 // 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);
29671 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 {
29672 if(!isWasmInitialized) {
29673 throw new Error("initializeWasm() must be awaited first!");
29675 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
29676 return nativeResponseValue;
29678 // void NetworkGraph_channel_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
29680 export function NetworkGraph_channel_failed(this_arg: number, short_channel_id: bigint, is_permanent: boolean): void {
29681 if(!isWasmInitialized) {
29682 throw new Error("initializeWasm() must be awaited first!");
29684 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed(this_arg, short_channel_id, is_permanent);
29685 // debug statements here
29687 // void NetworkGraph_node_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
29689 export function NetworkGraph_node_failed(this_arg: number, _node_id: number, is_permanent: boolean): void {
29690 if(!isWasmInitialized) {
29691 throw new Error("initializeWasm() must be awaited first!");
29693 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed(this_arg, _node_id, is_permanent);
29694 // debug statements here
29696 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
29698 export function NetworkGraph_remove_stale_channels_with_time(this_arg: number, current_time_unix: bigint): void {
29699 if(!isWasmInitialized) {
29700 throw new Error("initializeWasm() must be awaited first!");
29702 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
29703 // debug statements here
29705 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
29707 export function NetworkGraph_update_channel(this_arg: number, msg: number): number {
29708 if(!isWasmInitialized) {
29709 throw new Error("initializeWasm() must be awaited first!");
29711 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
29712 return nativeResponseValue;
29714 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
29716 export function NetworkGraph_update_channel_unsigned(this_arg: number, msg: number): number {
29717 if(!isWasmInitialized) {
29718 throw new Error("initializeWasm() must be awaited first!");
29720 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
29721 return nativeResponseValue;
29723 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
29725 export function ReadOnlyNetworkGraph_get_addresses(this_arg: number, pubkey: number): number {
29726 if(!isWasmInitialized) {
29727 throw new Error("initializeWasm() must be awaited first!");
29729 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
29730 return nativeResponseValue;
29732 // void RouteHop_free(struct LDKRouteHop this_obj);
29734 export function RouteHop_free(this_obj: number): void {
29735 if(!isWasmInitialized) {
29736 throw new Error("initializeWasm() must be awaited first!");
29738 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
29739 // debug statements here
29741 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29743 export function RouteHop_get_pubkey(this_ptr: number): number {
29744 if(!isWasmInitialized) {
29745 throw new Error("initializeWasm() must be awaited first!");
29747 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
29748 return nativeResponseValue;
29750 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29752 export function RouteHop_set_pubkey(this_ptr: number, val: number): void {
29753 if(!isWasmInitialized) {
29754 throw new Error("initializeWasm() must be awaited first!");
29756 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
29757 // debug statements here
29759 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29761 export function RouteHop_get_node_features(this_ptr: number): number {
29762 if(!isWasmInitialized) {
29763 throw new Error("initializeWasm() must be awaited first!");
29765 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
29766 return nativeResponseValue;
29768 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
29770 export function RouteHop_set_node_features(this_ptr: number, val: number): void {
29771 if(!isWasmInitialized) {
29772 throw new Error("initializeWasm() must be awaited first!");
29774 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
29775 // debug statements here
29777 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29779 export function RouteHop_get_short_channel_id(this_ptr: number): bigint {
29780 if(!isWasmInitialized) {
29781 throw new Error("initializeWasm() must be awaited first!");
29783 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
29784 return nativeResponseValue;
29786 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
29788 export function RouteHop_set_short_channel_id(this_ptr: number, val: bigint): void {
29789 if(!isWasmInitialized) {
29790 throw new Error("initializeWasm() must be awaited first!");
29792 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
29793 // debug statements here
29795 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29797 export function RouteHop_get_channel_features(this_ptr: number): number {
29798 if(!isWasmInitialized) {
29799 throw new Error("initializeWasm() must be awaited first!");
29801 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
29802 return nativeResponseValue;
29804 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
29806 export function RouteHop_set_channel_features(this_ptr: number, val: number): void {
29807 if(!isWasmInitialized) {
29808 throw new Error("initializeWasm() must be awaited first!");
29810 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
29811 // debug statements here
29813 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29815 export function RouteHop_get_fee_msat(this_ptr: number): bigint {
29816 if(!isWasmInitialized) {
29817 throw new Error("initializeWasm() must be awaited first!");
29819 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
29820 return nativeResponseValue;
29822 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
29824 export function RouteHop_set_fee_msat(this_ptr: number, val: bigint): void {
29825 if(!isWasmInitialized) {
29826 throw new Error("initializeWasm() must be awaited first!");
29828 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
29829 // debug statements here
29831 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29833 export function RouteHop_get_cltv_expiry_delta(this_ptr: number): number {
29834 if(!isWasmInitialized) {
29835 throw new Error("initializeWasm() must be awaited first!");
29837 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
29838 return nativeResponseValue;
29840 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
29842 export function RouteHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
29843 if(!isWasmInitialized) {
29844 throw new Error("initializeWasm() must be awaited first!");
29846 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
29847 // debug statements here
29849 // 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);
29851 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 {
29852 if(!isWasmInitialized) {
29853 throw new Error("initializeWasm() must be awaited first!");
29855 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);
29856 return nativeResponseValue;
29858 // uintptr_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
29860 export function RouteHop_clone_ptr(arg: number): number {
29861 if(!isWasmInitialized) {
29862 throw new Error("initializeWasm() must be awaited first!");
29864 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
29865 return nativeResponseValue;
29867 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
29869 export function RouteHop_clone(orig: number): number {
29870 if(!isWasmInitialized) {
29871 throw new Error("initializeWasm() must be awaited first!");
29873 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
29874 return nativeResponseValue;
29876 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
29878 export function RouteHop_hash(o: number): bigint {
29879 if(!isWasmInitialized) {
29880 throw new Error("initializeWasm() must be awaited first!");
29882 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
29883 return nativeResponseValue;
29885 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
29887 export function RouteHop_eq(a: number, b: number): boolean {
29888 if(!isWasmInitialized) {
29889 throw new Error("initializeWasm() must be awaited first!");
29891 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
29892 return nativeResponseValue;
29894 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
29896 export function RouteHop_write(obj: number): number {
29897 if(!isWasmInitialized) {
29898 throw new Error("initializeWasm() must be awaited first!");
29900 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
29901 return nativeResponseValue;
29903 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
29905 export function RouteHop_read(ser: number): number {
29906 if(!isWasmInitialized) {
29907 throw new Error("initializeWasm() must be awaited first!");
29909 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
29910 return nativeResponseValue;
29912 // void Route_free(struct LDKRoute this_obj);
29914 export function Route_free(this_obj: number): void {
29915 if(!isWasmInitialized) {
29916 throw new Error("initializeWasm() must be awaited first!");
29918 const nativeResponseValue = wasm.TS_Route_free(this_obj);
29919 // debug statements here
29921 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
29923 export function Route_get_paths(this_ptr: number): number {
29924 if(!isWasmInitialized) {
29925 throw new Error("initializeWasm() must be awaited first!");
29927 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
29928 return nativeResponseValue;
29930 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
29932 export function Route_set_paths(this_ptr: number, val: number): void {
29933 if(!isWasmInitialized) {
29934 throw new Error("initializeWasm() must be awaited first!");
29936 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
29937 // debug statements here
29939 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
29941 export function Route_get_payment_params(this_ptr: number): number {
29942 if(!isWasmInitialized) {
29943 throw new Error("initializeWasm() must be awaited first!");
29945 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
29946 return nativeResponseValue;
29948 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
29950 export function Route_set_payment_params(this_ptr: number, val: number): void {
29951 if(!isWasmInitialized) {
29952 throw new Error("initializeWasm() must be awaited first!");
29954 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
29955 // debug statements here
29957 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
29959 export function Route_new(paths_arg: number, payment_params_arg: number): number {
29960 if(!isWasmInitialized) {
29961 throw new Error("initializeWasm() must be awaited first!");
29963 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
29964 return nativeResponseValue;
29966 // uintptr_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
29968 export function Route_clone_ptr(arg: number): number {
29969 if(!isWasmInitialized) {
29970 throw new Error("initializeWasm() must be awaited first!");
29972 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
29973 return nativeResponseValue;
29975 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
29977 export function Route_clone(orig: number): number {
29978 if(!isWasmInitialized) {
29979 throw new Error("initializeWasm() must be awaited first!");
29981 const nativeResponseValue = wasm.TS_Route_clone(orig);
29982 return nativeResponseValue;
29984 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
29986 export function Route_hash(o: number): bigint {
29987 if(!isWasmInitialized) {
29988 throw new Error("initializeWasm() must be awaited first!");
29990 const nativeResponseValue = wasm.TS_Route_hash(o);
29991 return nativeResponseValue;
29993 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
29995 export function Route_eq(a: number, b: number): boolean {
29996 if(!isWasmInitialized) {
29997 throw new Error("initializeWasm() must be awaited first!");
29999 const nativeResponseValue = wasm.TS_Route_eq(a, b);
30000 return nativeResponseValue;
30002 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
30004 export function Route_get_total_fees(this_arg: number): bigint {
30005 if(!isWasmInitialized) {
30006 throw new Error("initializeWasm() must be awaited first!");
30008 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
30009 return nativeResponseValue;
30011 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
30013 export function Route_get_total_amount(this_arg: number): bigint {
30014 if(!isWasmInitialized) {
30015 throw new Error("initializeWasm() must be awaited first!");
30017 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
30018 return nativeResponseValue;
30020 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
30022 export function Route_write(obj: number): number {
30023 if(!isWasmInitialized) {
30024 throw new Error("initializeWasm() must be awaited first!");
30026 const nativeResponseValue = wasm.TS_Route_write(obj);
30027 return nativeResponseValue;
30029 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
30031 export function Route_read(ser: number): number {
30032 if(!isWasmInitialized) {
30033 throw new Error("initializeWasm() must be awaited first!");
30035 const nativeResponseValue = wasm.TS_Route_read(ser);
30036 return nativeResponseValue;
30038 // void RouteParameters_free(struct LDKRouteParameters this_obj);
30040 export function RouteParameters_free(this_obj: number): void {
30041 if(!isWasmInitialized) {
30042 throw new Error("initializeWasm() must be awaited first!");
30044 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
30045 // debug statements here
30047 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30049 export function RouteParameters_get_payment_params(this_ptr: number): number {
30050 if(!isWasmInitialized) {
30051 throw new Error("initializeWasm() must be awaited first!");
30053 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
30054 return nativeResponseValue;
30056 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
30058 export function RouteParameters_set_payment_params(this_ptr: number, val: number): void {
30059 if(!isWasmInitialized) {
30060 throw new Error("initializeWasm() must be awaited first!");
30062 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
30063 // debug statements here
30065 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30067 export function RouteParameters_get_final_value_msat(this_ptr: number): bigint {
30068 if(!isWasmInitialized) {
30069 throw new Error("initializeWasm() must be awaited first!");
30071 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
30072 return nativeResponseValue;
30074 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
30076 export function RouteParameters_set_final_value_msat(this_ptr: number, val: bigint): void {
30077 if(!isWasmInitialized) {
30078 throw new Error("initializeWasm() must be awaited first!");
30080 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
30081 // debug statements here
30083 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30085 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: number): number {
30086 if(!isWasmInitialized) {
30087 throw new Error("initializeWasm() must be awaited first!");
30089 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
30090 return nativeResponseValue;
30092 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
30094 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: number, val: number): void {
30095 if(!isWasmInitialized) {
30096 throw new Error("initializeWasm() must be awaited first!");
30098 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
30099 // debug statements here
30101 // 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);
30103 export function RouteParameters_new(payment_params_arg: number, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): number {
30104 if(!isWasmInitialized) {
30105 throw new Error("initializeWasm() must be awaited first!");
30107 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
30108 return nativeResponseValue;
30110 // uintptr_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
30112 export function RouteParameters_clone_ptr(arg: number): number {
30113 if(!isWasmInitialized) {
30114 throw new Error("initializeWasm() must be awaited first!");
30116 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
30117 return nativeResponseValue;
30119 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
30121 export function RouteParameters_clone(orig: number): number {
30122 if(!isWasmInitialized) {
30123 throw new Error("initializeWasm() must be awaited first!");
30125 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
30126 return nativeResponseValue;
30128 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
30130 export function RouteParameters_write(obj: number): number {
30131 if(!isWasmInitialized) {
30132 throw new Error("initializeWasm() must be awaited first!");
30134 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
30135 return nativeResponseValue;
30137 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
30139 export function RouteParameters_read(ser: number): number {
30140 if(!isWasmInitialized) {
30141 throw new Error("initializeWasm() must be awaited first!");
30143 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
30144 return nativeResponseValue;
30146 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
30148 export function PaymentParameters_free(this_obj: number): void {
30149 if(!isWasmInitialized) {
30150 throw new Error("initializeWasm() must be awaited first!");
30152 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
30153 // debug statements here
30155 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30157 export function PaymentParameters_get_payee_pubkey(this_ptr: number): number {
30158 if(!isWasmInitialized) {
30159 throw new Error("initializeWasm() must be awaited first!");
30161 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
30162 return nativeResponseValue;
30164 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30166 export function PaymentParameters_set_payee_pubkey(this_ptr: number, val: number): void {
30167 if(!isWasmInitialized) {
30168 throw new Error("initializeWasm() must be awaited first!");
30170 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
30171 // debug statements here
30173 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30175 export function PaymentParameters_get_features(this_ptr: number): number {
30176 if(!isWasmInitialized) {
30177 throw new Error("initializeWasm() must be awaited first!");
30179 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
30180 return nativeResponseValue;
30182 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
30184 export function PaymentParameters_set_features(this_ptr: number, val: number): void {
30185 if(!isWasmInitialized) {
30186 throw new Error("initializeWasm() must be awaited first!");
30188 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
30189 // debug statements here
30191 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30193 export function PaymentParameters_get_route_hints(this_ptr: number): number {
30194 if(!isWasmInitialized) {
30195 throw new Error("initializeWasm() must be awaited first!");
30197 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
30198 return nativeResponseValue;
30200 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
30202 export function PaymentParameters_set_route_hints(this_ptr: number, val: number): void {
30203 if(!isWasmInitialized) {
30204 throw new Error("initializeWasm() must be awaited first!");
30206 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
30207 // debug statements here
30209 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30211 export function PaymentParameters_get_expiry_time(this_ptr: number): number {
30212 if(!isWasmInitialized) {
30213 throw new Error("initializeWasm() must be awaited first!");
30215 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
30216 return nativeResponseValue;
30218 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30220 export function PaymentParameters_set_expiry_time(this_ptr: number, val: number): void {
30221 if(!isWasmInitialized) {
30222 throw new Error("initializeWasm() must be awaited first!");
30224 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
30225 // debug statements here
30227 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30229 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: number): number {
30230 if(!isWasmInitialized) {
30231 throw new Error("initializeWasm() must be awaited first!");
30233 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
30234 return nativeResponseValue;
30236 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
30238 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: number, val: number): void {
30239 if(!isWasmInitialized) {
30240 throw new Error("initializeWasm() must be awaited first!");
30242 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
30243 // debug statements here
30245 // uint8_t PaymentParameters_get_max_mpp_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30247 export function PaymentParameters_get_max_mpp_path_count(this_ptr: number): number {
30248 if(!isWasmInitialized) {
30249 throw new Error("initializeWasm() must be awaited first!");
30251 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_mpp_path_count(this_ptr);
30252 return nativeResponseValue;
30254 // void PaymentParameters_set_max_mpp_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
30256 export function PaymentParameters_set_max_mpp_path_count(this_ptr: number, val: number): void {
30257 if(!isWasmInitialized) {
30258 throw new Error("initializeWasm() must be awaited first!");
30260 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_mpp_path_count(this_ptr, val);
30261 // debug statements here
30263 // 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_mpp_path_count_arg);
30265 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_mpp_path_count_arg: number): number {
30266 if(!isWasmInitialized) {
30267 throw new Error("initializeWasm() must be awaited first!");
30269 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg, max_mpp_path_count_arg);
30270 return nativeResponseValue;
30272 // uintptr_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
30274 export function PaymentParameters_clone_ptr(arg: number): number {
30275 if(!isWasmInitialized) {
30276 throw new Error("initializeWasm() must be awaited first!");
30278 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
30279 return nativeResponseValue;
30281 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
30283 export function PaymentParameters_clone(orig: number): number {
30284 if(!isWasmInitialized) {
30285 throw new Error("initializeWasm() must be awaited first!");
30287 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
30288 return nativeResponseValue;
30290 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
30292 export function PaymentParameters_hash(o: number): bigint {
30293 if(!isWasmInitialized) {
30294 throw new Error("initializeWasm() must be awaited first!");
30296 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
30297 return nativeResponseValue;
30299 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
30301 export function PaymentParameters_eq(a: number, b: number): boolean {
30302 if(!isWasmInitialized) {
30303 throw new Error("initializeWasm() must be awaited first!");
30305 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
30306 return nativeResponseValue;
30308 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
30310 export function PaymentParameters_write(obj: number): number {
30311 if(!isWasmInitialized) {
30312 throw new Error("initializeWasm() must be awaited first!");
30314 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
30315 return nativeResponseValue;
30317 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
30319 export function PaymentParameters_read(ser: number): number {
30320 if(!isWasmInitialized) {
30321 throw new Error("initializeWasm() must be awaited first!");
30323 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
30324 return nativeResponseValue;
30326 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
30328 export function PaymentParameters_from_node_id(payee_pubkey: number): number {
30329 if(!isWasmInitialized) {
30330 throw new Error("initializeWasm() must be awaited first!");
30332 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
30333 return nativeResponseValue;
30335 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
30337 export function PaymentParameters_for_keysend(payee_pubkey: number): number {
30338 if(!isWasmInitialized) {
30339 throw new Error("initializeWasm() must be awaited first!");
30341 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
30342 return nativeResponseValue;
30344 // void RouteHint_free(struct LDKRouteHint this_obj);
30346 export function RouteHint_free(this_obj: number): void {
30347 if(!isWasmInitialized) {
30348 throw new Error("initializeWasm() must be awaited first!");
30350 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
30351 // debug statements here
30353 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
30355 export function RouteHint_get_a(this_ptr: number): number {
30356 if(!isWasmInitialized) {
30357 throw new Error("initializeWasm() must be awaited first!");
30359 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
30360 return nativeResponseValue;
30362 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
30364 export function RouteHint_set_a(this_ptr: number, val: number): void {
30365 if(!isWasmInitialized) {
30366 throw new Error("initializeWasm() must be awaited first!");
30368 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
30369 // debug statements here
30371 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
30373 export function RouteHint_new(a_arg: number): number {
30374 if(!isWasmInitialized) {
30375 throw new Error("initializeWasm() must be awaited first!");
30377 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
30378 return nativeResponseValue;
30380 // uintptr_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
30382 export function RouteHint_clone_ptr(arg: number): number {
30383 if(!isWasmInitialized) {
30384 throw new Error("initializeWasm() must be awaited first!");
30386 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
30387 return nativeResponseValue;
30389 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
30391 export function RouteHint_clone(orig: number): number {
30392 if(!isWasmInitialized) {
30393 throw new Error("initializeWasm() must be awaited first!");
30395 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
30396 return nativeResponseValue;
30398 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
30400 export function RouteHint_hash(o: number): bigint {
30401 if(!isWasmInitialized) {
30402 throw new Error("initializeWasm() must be awaited first!");
30404 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
30405 return nativeResponseValue;
30407 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
30409 export function RouteHint_eq(a: number, b: number): boolean {
30410 if(!isWasmInitialized) {
30411 throw new Error("initializeWasm() must be awaited first!");
30413 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
30414 return nativeResponseValue;
30416 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
30418 export function RouteHint_write(obj: number): number {
30419 if(!isWasmInitialized) {
30420 throw new Error("initializeWasm() must be awaited first!");
30422 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
30423 return nativeResponseValue;
30425 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
30427 export function RouteHint_read(ser: number): number {
30428 if(!isWasmInitialized) {
30429 throw new Error("initializeWasm() must be awaited first!");
30431 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
30432 return nativeResponseValue;
30434 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
30436 export function RouteHintHop_free(this_obj: number): void {
30437 if(!isWasmInitialized) {
30438 throw new Error("initializeWasm() must be awaited first!");
30440 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
30441 // debug statements here
30443 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30445 export function RouteHintHop_get_src_node_id(this_ptr: number): number {
30446 if(!isWasmInitialized) {
30447 throw new Error("initializeWasm() must be awaited first!");
30449 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
30450 return nativeResponseValue;
30452 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30454 export function RouteHintHop_set_src_node_id(this_ptr: number, val: number): void {
30455 if(!isWasmInitialized) {
30456 throw new Error("initializeWasm() must be awaited first!");
30458 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
30459 // debug statements here
30461 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30463 export function RouteHintHop_get_short_channel_id(this_ptr: number): bigint {
30464 if(!isWasmInitialized) {
30465 throw new Error("initializeWasm() must be awaited first!");
30467 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
30468 return nativeResponseValue;
30470 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
30472 export function RouteHintHop_set_short_channel_id(this_ptr: number, val: bigint): void {
30473 if(!isWasmInitialized) {
30474 throw new Error("initializeWasm() must be awaited first!");
30476 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
30477 // debug statements here
30479 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30481 export function RouteHintHop_get_fees(this_ptr: number): number {
30482 if(!isWasmInitialized) {
30483 throw new Error("initializeWasm() must be awaited first!");
30485 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
30486 return nativeResponseValue;
30488 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
30490 export function RouteHintHop_set_fees(this_ptr: number, val: number): void {
30491 if(!isWasmInitialized) {
30492 throw new Error("initializeWasm() must be awaited first!");
30494 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
30495 // debug statements here
30497 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30499 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: number): number {
30500 if(!isWasmInitialized) {
30501 throw new Error("initializeWasm() must be awaited first!");
30503 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
30504 return nativeResponseValue;
30506 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
30508 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
30509 if(!isWasmInitialized) {
30510 throw new Error("initializeWasm() must be awaited first!");
30512 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
30513 // debug statements here
30515 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30517 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: number): number {
30518 if(!isWasmInitialized) {
30519 throw new Error("initializeWasm() must be awaited first!");
30521 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
30522 return nativeResponseValue;
30524 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30526 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: number, val: number): void {
30527 if(!isWasmInitialized) {
30528 throw new Error("initializeWasm() must be awaited first!");
30530 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
30531 // debug statements here
30533 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30535 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: number): number {
30536 if(!isWasmInitialized) {
30537 throw new Error("initializeWasm() must be awaited first!");
30539 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
30540 return nativeResponseValue;
30542 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30544 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: number, val: number): void {
30545 if(!isWasmInitialized) {
30546 throw new Error("initializeWasm() must be awaited first!");
30548 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
30549 // debug statements here
30551 // 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);
30553 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 {
30554 if(!isWasmInitialized) {
30555 throw new Error("initializeWasm() must be awaited first!");
30557 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);
30558 return nativeResponseValue;
30560 // uintptr_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
30562 export function RouteHintHop_clone_ptr(arg: number): number {
30563 if(!isWasmInitialized) {
30564 throw new Error("initializeWasm() must be awaited first!");
30566 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
30567 return nativeResponseValue;
30569 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
30571 export function RouteHintHop_clone(orig: number): number {
30572 if(!isWasmInitialized) {
30573 throw new Error("initializeWasm() must be awaited first!");
30575 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
30576 return nativeResponseValue;
30578 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
30580 export function RouteHintHop_hash(o: number): bigint {
30581 if(!isWasmInitialized) {
30582 throw new Error("initializeWasm() must be awaited first!");
30584 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
30585 return nativeResponseValue;
30587 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
30589 export function RouteHintHop_eq(a: number, b: number): boolean {
30590 if(!isWasmInitialized) {
30591 throw new Error("initializeWasm() must be awaited first!");
30593 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
30594 return nativeResponseValue;
30596 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
30598 export function RouteHintHop_write(obj: number): number {
30599 if(!isWasmInitialized) {
30600 throw new Error("initializeWasm() must be awaited first!");
30602 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
30603 return nativeResponseValue;
30605 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
30607 export function RouteHintHop_read(ser: number): number {
30608 if(!isWasmInitialized) {
30609 throw new Error("initializeWasm() must be awaited first!");
30611 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
30612 return nativeResponseValue;
30614 // 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]);
30616 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 {
30617 if(!isWasmInitialized) {
30618 throw new Error("initializeWasm() must be awaited first!");
30620 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
30621 return nativeResponseValue;
30623 // 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]);
30625 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 {
30626 if(!isWasmInitialized) {
30627 throw new Error("initializeWasm() must be awaited first!");
30629 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
30630 return nativeResponseValue;
30632 // void Score_free(struct LDKScore this_ptr);
30634 export function Score_free(this_ptr: number): void {
30635 if(!isWasmInitialized) {
30636 throw new Error("initializeWasm() must be awaited first!");
30638 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
30639 // debug statements here
30641 // void LockableScore_free(struct LDKLockableScore this_ptr);
30643 export function LockableScore_free(this_ptr: number): void {
30644 if(!isWasmInitialized) {
30645 throw new Error("initializeWasm() must be awaited first!");
30647 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
30648 // debug statements here
30650 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
30652 export function MultiThreadedLockableScore_free(this_obj: number): void {
30653 if(!isWasmInitialized) {
30654 throw new Error("initializeWasm() must be awaited first!");
30656 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
30657 // debug statements here
30659 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
30661 export function MultiThreadedLockableScore_write(obj: number): number {
30662 if(!isWasmInitialized) {
30663 throw new Error("initializeWasm() must be awaited first!");
30665 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
30666 return nativeResponseValue;
30668 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
30670 export function MultiThreadedLockableScore_new(score: number): number {
30671 if(!isWasmInitialized) {
30672 throw new Error("initializeWasm() must be awaited first!");
30674 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
30675 return nativeResponseValue;
30677 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
30679 export function ChannelUsage_free(this_obj: number): void {
30680 if(!isWasmInitialized) {
30681 throw new Error("initializeWasm() must be awaited first!");
30683 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
30684 // debug statements here
30686 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
30688 export function ChannelUsage_get_amount_msat(this_ptr: number): bigint {
30689 if(!isWasmInitialized) {
30690 throw new Error("initializeWasm() must be awaited first!");
30692 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
30693 return nativeResponseValue;
30695 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
30697 export function ChannelUsage_set_amount_msat(this_ptr: number, val: bigint): void {
30698 if(!isWasmInitialized) {
30699 throw new Error("initializeWasm() must be awaited first!");
30701 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
30702 // debug statements here
30704 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
30706 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: number): bigint {
30707 if(!isWasmInitialized) {
30708 throw new Error("initializeWasm() must be awaited first!");
30710 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
30711 return nativeResponseValue;
30713 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
30715 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: number, val: bigint): void {
30716 if(!isWasmInitialized) {
30717 throw new Error("initializeWasm() must be awaited first!");
30719 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
30720 // debug statements here
30722 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
30724 export function ChannelUsage_get_effective_capacity(this_ptr: number): number {
30725 if(!isWasmInitialized) {
30726 throw new Error("initializeWasm() must be awaited first!");
30728 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
30729 return nativeResponseValue;
30731 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
30733 export function ChannelUsage_set_effective_capacity(this_ptr: number, val: number): void {
30734 if(!isWasmInitialized) {
30735 throw new Error("initializeWasm() must be awaited first!");
30737 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
30738 // debug statements here
30740 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
30742 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: number): number {
30743 if(!isWasmInitialized) {
30744 throw new Error("initializeWasm() must be awaited first!");
30746 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
30747 return nativeResponseValue;
30749 // uintptr_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
30751 export function ChannelUsage_clone_ptr(arg: number): number {
30752 if(!isWasmInitialized) {
30753 throw new Error("initializeWasm() must be awaited first!");
30755 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
30756 return nativeResponseValue;
30758 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
30760 export function ChannelUsage_clone(orig: number): number {
30761 if(!isWasmInitialized) {
30762 throw new Error("initializeWasm() must be awaited first!");
30764 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
30765 return nativeResponseValue;
30767 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
30769 export function FixedPenaltyScorer_free(this_obj: number): void {
30770 if(!isWasmInitialized) {
30771 throw new Error("initializeWasm() must be awaited first!");
30773 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
30774 // debug statements here
30776 // uintptr_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
30778 export function FixedPenaltyScorer_clone_ptr(arg: number): number {
30779 if(!isWasmInitialized) {
30780 throw new Error("initializeWasm() must be awaited first!");
30782 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
30783 return nativeResponseValue;
30785 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
30787 export function FixedPenaltyScorer_clone(orig: number): number {
30788 if(!isWasmInitialized) {
30789 throw new Error("initializeWasm() must be awaited first!");
30791 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
30792 return nativeResponseValue;
30794 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
30796 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): number {
30797 if(!isWasmInitialized) {
30798 throw new Error("initializeWasm() must be awaited first!");
30800 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
30801 return nativeResponseValue;
30803 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
30805 export function FixedPenaltyScorer_as_Score(this_arg: number): number {
30806 if(!isWasmInitialized) {
30807 throw new Error("initializeWasm() must be awaited first!");
30809 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
30810 return nativeResponseValue;
30812 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
30814 export function FixedPenaltyScorer_write(obj: number): number {
30815 if(!isWasmInitialized) {
30816 throw new Error("initializeWasm() must be awaited first!");
30818 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
30819 return nativeResponseValue;
30821 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
30823 export function FixedPenaltyScorer_read(ser: number, arg: bigint): number {
30824 if(!isWasmInitialized) {
30825 throw new Error("initializeWasm() must be awaited first!");
30827 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
30828 return nativeResponseValue;
30830 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
30832 export function ProbabilisticScorer_free(this_obj: number): void {
30833 if(!isWasmInitialized) {
30834 throw new Error("initializeWasm() must be awaited first!");
30836 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
30837 // debug statements here
30839 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
30841 export function ProbabilisticScoringParameters_free(this_obj: number): void {
30842 if(!isWasmInitialized) {
30843 throw new Error("initializeWasm() must be awaited first!");
30845 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
30846 // debug statements here
30848 // uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30850 export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: number): bigint {
30851 if(!isWasmInitialized) {
30852 throw new Error("initializeWasm() must be awaited first!");
30854 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
30855 return nativeResponseValue;
30857 // void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30859 export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: number, val: bigint): void {
30860 if(!isWasmInitialized) {
30861 throw new Error("initializeWasm() must be awaited first!");
30863 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
30864 // debug statements here
30866 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30868 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: number): bigint {
30869 if(!isWasmInitialized) {
30870 throw new Error("initializeWasm() must be awaited first!");
30872 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
30873 return nativeResponseValue;
30875 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30877 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
30878 if(!isWasmInitialized) {
30879 throw new Error("initializeWasm() must be awaited first!");
30881 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
30882 // debug statements here
30884 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30886 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: number): bigint {
30887 if(!isWasmInitialized) {
30888 throw new Error("initializeWasm() must be awaited first!");
30890 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
30891 return nativeResponseValue;
30893 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30895 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: number, val: bigint): void {
30896 if(!isWasmInitialized) {
30897 throw new Error("initializeWasm() must be awaited first!");
30899 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
30900 // debug statements here
30902 // uint64_t ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30904 export function ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(this_ptr: number): bigint {
30905 if(!isWasmInitialized) {
30906 throw new Error("initializeWasm() must be awaited first!");
30908 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(this_ptr);
30909 return nativeResponseValue;
30911 // void ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30913 export function ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
30914 if(!isWasmInitialized) {
30915 throw new Error("initializeWasm() must be awaited first!");
30917 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(this_ptr, val);
30918 // debug statements here
30920 // uint64_t ProbabilisticScoringParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30922 export function ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: number): bigint {
30923 if(!isWasmInitialized) {
30924 throw new Error("initializeWasm() must be awaited first!");
30926 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr);
30927 return nativeResponseValue;
30929 // void ProbabilisticScoringParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30931 export function ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: number, val: bigint): void {
30932 if(!isWasmInitialized) {
30933 throw new Error("initializeWasm() must be awaited first!");
30935 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr, val);
30936 // debug statements here
30938 // uintptr_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
30940 export function ProbabilisticScoringParameters_clone_ptr(arg: number): number {
30941 if(!isWasmInitialized) {
30942 throw new Error("initializeWasm() must be awaited first!");
30944 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
30945 return nativeResponseValue;
30947 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
30949 export function ProbabilisticScoringParameters_clone(orig: number): number {
30950 if(!isWasmInitialized) {
30951 throw new Error("initializeWasm() must be awaited first!");
30953 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
30954 return nativeResponseValue;
30956 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
30958 export function ProbabilisticScorer_new(params: number, network_graph: number, logger: number): number {
30959 if(!isWasmInitialized) {
30960 throw new Error("initializeWasm() must be awaited first!");
30962 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
30963 return nativeResponseValue;
30965 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
30967 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: number): void {
30968 if(!isWasmInitialized) {
30969 throw new Error("initializeWasm() must be awaited first!");
30971 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
30972 // debug statements here
30974 // 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);
30976 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: number, scid: bigint, target: number): number {
30977 if(!isWasmInitialized) {
30978 throw new Error("initializeWasm() must be awaited first!");
30980 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
30981 return nativeResponseValue;
30983 // void ProbabilisticScorer_add_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
30985 export function ProbabilisticScorer_add_banned(this_arg: number, node_id: number): void {
30986 if(!isWasmInitialized) {
30987 throw new Error("initializeWasm() must be awaited first!");
30989 const nativeResponseValue = wasm.TS_ProbabilisticScorer_add_banned(this_arg, node_id);
30990 // debug statements here
30992 // void ProbabilisticScorer_remove_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
30994 export function ProbabilisticScorer_remove_banned(this_arg: number, node_id: number): void {
30995 if(!isWasmInitialized) {
30996 throw new Error("initializeWasm() must be awaited first!");
30998 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_banned(this_arg, node_id);
30999 // debug statements here
31001 // void ProbabilisticScorer_clear_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
31003 export function ProbabilisticScorer_clear_banned(this_arg: number): void {
31004 if(!isWasmInitialized) {
31005 throw new Error("initializeWasm() must be awaited first!");
31007 const nativeResponseValue = wasm.TS_ProbabilisticScorer_clear_banned(this_arg);
31008 // debug statements here
31010 // void ProbabilisticScoringParameters_add_banned_from_list(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
31012 export function ProbabilisticScoringParameters_add_banned_from_list(this_arg: number, node_ids: number): void {
31013 if(!isWasmInitialized) {
31014 throw new Error("initializeWasm() must be awaited first!");
31016 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_add_banned_from_list(this_arg, node_ids);
31017 // debug statements here
31019 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
31021 export function ProbabilisticScoringParameters_default(): number {
31022 if(!isWasmInitialized) {
31023 throw new Error("initializeWasm() must be awaited first!");
31025 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
31026 return nativeResponseValue;
31028 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
31030 export function ProbabilisticScorer_as_Score(this_arg: number): number {
31031 if(!isWasmInitialized) {
31032 throw new Error("initializeWasm() must be awaited first!");
31034 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
31035 return nativeResponseValue;
31037 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
31039 export function ProbabilisticScorer_write(obj: number): number {
31040 if(!isWasmInitialized) {
31041 throw new Error("initializeWasm() must be awaited first!");
31043 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
31044 return nativeResponseValue;
31046 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
31048 export function ProbabilisticScorer_read(ser: number, arg_a: number, arg_b: number, arg_c: number): number {
31049 if(!isWasmInitialized) {
31050 throw new Error("initializeWasm() must be awaited first!");
31052 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
31053 return nativeResponseValue;
31055 // void ParseError_free(struct LDKParseError this_ptr);
31057 export function ParseError_free(this_ptr: number): void {
31058 if(!isWasmInitialized) {
31059 throw new Error("initializeWasm() must be awaited first!");
31061 const nativeResponseValue = wasm.TS_ParseError_free(this_ptr);
31062 // debug statements here
31064 // uintptr_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg);
31066 export function ParseError_clone_ptr(arg: number): number {
31067 if(!isWasmInitialized) {
31068 throw new Error("initializeWasm() must be awaited first!");
31070 const nativeResponseValue = wasm.TS_ParseError_clone_ptr(arg);
31071 return nativeResponseValue;
31073 // struct LDKParseError ParseError_clone(const struct LDKParseError *NONNULL_PTR orig);
31075 export function ParseError_clone(orig: number): number {
31076 if(!isWasmInitialized) {
31077 throw new Error("initializeWasm() must be awaited first!");
31079 const nativeResponseValue = wasm.TS_ParseError_clone(orig);
31080 return nativeResponseValue;
31082 // struct LDKParseError ParseError_bech32_error(struct LDKBech32Error a);
31084 export function ParseError_bech32_error(a: number): number {
31085 if(!isWasmInitialized) {
31086 throw new Error("initializeWasm() must be awaited first!");
31088 const nativeResponseValue = wasm.TS_ParseError_bech32_error(a);
31089 return nativeResponseValue;
31091 // struct LDKParseError ParseError_parse_amount_error(struct LDKError a);
31093 export function ParseError_parse_amount_error(a: number): number {
31094 if(!isWasmInitialized) {
31095 throw new Error("initializeWasm() must be awaited first!");
31097 const nativeResponseValue = wasm.TS_ParseError_parse_amount_error(a);
31098 return nativeResponseValue;
31100 // struct LDKParseError ParseError_malformed_signature(enum LDKSecp256k1Error a);
31102 export function ParseError_malformed_signature(a: Secp256k1Error): number {
31103 if(!isWasmInitialized) {
31104 throw new Error("initializeWasm() must be awaited first!");
31106 const nativeResponseValue = wasm.TS_ParseError_malformed_signature(a);
31107 return nativeResponseValue;
31109 // struct LDKParseError ParseError_bad_prefix(void);
31111 export function ParseError_bad_prefix(): number {
31112 if(!isWasmInitialized) {
31113 throw new Error("initializeWasm() must be awaited first!");
31115 const nativeResponseValue = wasm.TS_ParseError_bad_prefix();
31116 return nativeResponseValue;
31118 // struct LDKParseError ParseError_unknown_currency(void);
31120 export function ParseError_unknown_currency(): number {
31121 if(!isWasmInitialized) {
31122 throw new Error("initializeWasm() must be awaited first!");
31124 const nativeResponseValue = wasm.TS_ParseError_unknown_currency();
31125 return nativeResponseValue;
31127 // struct LDKParseError ParseError_unknown_si_prefix(void);
31129 export function ParseError_unknown_si_prefix(): number {
31130 if(!isWasmInitialized) {
31131 throw new Error("initializeWasm() must be awaited first!");
31133 const nativeResponseValue = wasm.TS_ParseError_unknown_si_prefix();
31134 return nativeResponseValue;
31136 // struct LDKParseError ParseError_malformed_hrp(void);
31138 export function ParseError_malformed_hrp(): number {
31139 if(!isWasmInitialized) {
31140 throw new Error("initializeWasm() must be awaited first!");
31142 const nativeResponseValue = wasm.TS_ParseError_malformed_hrp();
31143 return nativeResponseValue;
31145 // struct LDKParseError ParseError_too_short_data_part(void);
31147 export function ParseError_too_short_data_part(): number {
31148 if(!isWasmInitialized) {
31149 throw new Error("initializeWasm() must be awaited first!");
31151 const nativeResponseValue = wasm.TS_ParseError_too_short_data_part();
31152 return nativeResponseValue;
31154 // struct LDKParseError ParseError_unexpected_end_of_tagged_fields(void);
31156 export function ParseError_unexpected_end_of_tagged_fields(): number {
31157 if(!isWasmInitialized) {
31158 throw new Error("initializeWasm() must be awaited first!");
31160 const nativeResponseValue = wasm.TS_ParseError_unexpected_end_of_tagged_fields();
31161 return nativeResponseValue;
31163 // struct LDKParseError ParseError_description_decode_error(struct LDKError a);
31165 export function ParseError_description_decode_error(a: number): number {
31166 if(!isWasmInitialized) {
31167 throw new Error("initializeWasm() must be awaited first!");
31169 const nativeResponseValue = wasm.TS_ParseError_description_decode_error(a);
31170 return nativeResponseValue;
31172 // struct LDKParseError ParseError_padding_error(void);
31174 export function ParseError_padding_error(): number {
31175 if(!isWasmInitialized) {
31176 throw new Error("initializeWasm() must be awaited first!");
31178 const nativeResponseValue = wasm.TS_ParseError_padding_error();
31179 return nativeResponseValue;
31181 // struct LDKParseError ParseError_integer_overflow_error(void);
31183 export function ParseError_integer_overflow_error(): number {
31184 if(!isWasmInitialized) {
31185 throw new Error("initializeWasm() must be awaited first!");
31187 const nativeResponseValue = wasm.TS_ParseError_integer_overflow_error();
31188 return nativeResponseValue;
31190 // struct LDKParseError ParseError_invalid_seg_wit_program_length(void);
31192 export function ParseError_invalid_seg_wit_program_length(): number {
31193 if(!isWasmInitialized) {
31194 throw new Error("initializeWasm() must be awaited first!");
31196 const nativeResponseValue = wasm.TS_ParseError_invalid_seg_wit_program_length();
31197 return nativeResponseValue;
31199 // struct LDKParseError ParseError_invalid_pub_key_hash_length(void);
31201 export function ParseError_invalid_pub_key_hash_length(): number {
31202 if(!isWasmInitialized) {
31203 throw new Error("initializeWasm() must be awaited first!");
31205 const nativeResponseValue = wasm.TS_ParseError_invalid_pub_key_hash_length();
31206 return nativeResponseValue;
31208 // struct LDKParseError ParseError_invalid_script_hash_length(void);
31210 export function ParseError_invalid_script_hash_length(): number {
31211 if(!isWasmInitialized) {
31212 throw new Error("initializeWasm() must be awaited first!");
31214 const nativeResponseValue = wasm.TS_ParseError_invalid_script_hash_length();
31215 return nativeResponseValue;
31217 // struct LDKParseError ParseError_invalid_recovery_id(void);
31219 export function ParseError_invalid_recovery_id(): number {
31220 if(!isWasmInitialized) {
31221 throw new Error("initializeWasm() must be awaited first!");
31223 const nativeResponseValue = wasm.TS_ParseError_invalid_recovery_id();
31224 return nativeResponseValue;
31226 // struct LDKParseError ParseError_invalid_slice_length(struct LDKStr a);
31228 export function ParseError_invalid_slice_length(a: number): number {
31229 if(!isWasmInitialized) {
31230 throw new Error("initializeWasm() must be awaited first!");
31232 const nativeResponseValue = wasm.TS_ParseError_invalid_slice_length(a);
31233 return nativeResponseValue;
31235 // struct LDKParseError ParseError_skip(void);
31237 export function ParseError_skip(): number {
31238 if(!isWasmInitialized) {
31239 throw new Error("initializeWasm() must be awaited first!");
31241 const nativeResponseValue = wasm.TS_ParseError_skip();
31242 return nativeResponseValue;
31244 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
31246 export function ParseOrSemanticError_free(this_ptr: number): void {
31247 if(!isWasmInitialized) {
31248 throw new Error("initializeWasm() must be awaited first!");
31250 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
31251 // debug statements here
31253 // uintptr_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
31255 export function ParseOrSemanticError_clone_ptr(arg: number): number {
31256 if(!isWasmInitialized) {
31257 throw new Error("initializeWasm() must be awaited first!");
31259 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
31260 return nativeResponseValue;
31262 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
31264 export function ParseOrSemanticError_clone(orig: number): number {
31265 if(!isWasmInitialized) {
31266 throw new Error("initializeWasm() must be awaited first!");
31268 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
31269 return nativeResponseValue;
31271 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKParseError a);
31273 export function ParseOrSemanticError_parse_error(a: number): number {
31274 if(!isWasmInitialized) {
31275 throw new Error("initializeWasm() must be awaited first!");
31277 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
31278 return nativeResponseValue;
31280 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKSemanticError a);
31282 export function ParseOrSemanticError_semantic_error(a: SemanticError): number {
31283 if(!isWasmInitialized) {
31284 throw new Error("initializeWasm() must be awaited first!");
31286 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
31287 return nativeResponseValue;
31289 // void Invoice_free(struct LDKInvoice this_obj);
31291 export function Invoice_free(this_obj: number): void {
31292 if(!isWasmInitialized) {
31293 throw new Error("initializeWasm() must be awaited first!");
31295 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
31296 // debug statements here
31298 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
31300 export function Invoice_eq(a: number, b: number): boolean {
31301 if(!isWasmInitialized) {
31302 throw new Error("initializeWasm() must be awaited first!");
31304 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
31305 return nativeResponseValue;
31307 // uintptr_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
31309 export function Invoice_clone_ptr(arg: number): number {
31310 if(!isWasmInitialized) {
31311 throw new Error("initializeWasm() must be awaited first!");
31313 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
31314 return nativeResponseValue;
31316 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
31318 export function Invoice_clone(orig: number): number {
31319 if(!isWasmInitialized) {
31320 throw new Error("initializeWasm() must be awaited first!");
31322 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
31323 return nativeResponseValue;
31325 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
31327 export function SignedRawInvoice_free(this_obj: number): void {
31328 if(!isWasmInitialized) {
31329 throw new Error("initializeWasm() must be awaited first!");
31331 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
31332 // debug statements here
31334 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
31336 export function SignedRawInvoice_eq(a: number, b: number): boolean {
31337 if(!isWasmInitialized) {
31338 throw new Error("initializeWasm() must be awaited first!");
31340 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
31341 return nativeResponseValue;
31343 // uintptr_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
31345 export function SignedRawInvoice_clone_ptr(arg: number): number {
31346 if(!isWasmInitialized) {
31347 throw new Error("initializeWasm() must be awaited first!");
31349 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
31350 return nativeResponseValue;
31352 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
31354 export function SignedRawInvoice_clone(orig: number): number {
31355 if(!isWasmInitialized) {
31356 throw new Error("initializeWasm() must be awaited first!");
31358 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
31359 return nativeResponseValue;
31361 // void RawInvoice_free(struct LDKRawInvoice this_obj);
31363 export function RawInvoice_free(this_obj: number): void {
31364 if(!isWasmInitialized) {
31365 throw new Error("initializeWasm() must be awaited first!");
31367 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
31368 // debug statements here
31370 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
31372 export function RawInvoice_get_data(this_ptr: number): number {
31373 if(!isWasmInitialized) {
31374 throw new Error("initializeWasm() must be awaited first!");
31376 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
31377 return nativeResponseValue;
31379 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
31381 export function RawInvoice_set_data(this_ptr: number, val: number): void {
31382 if(!isWasmInitialized) {
31383 throw new Error("initializeWasm() must be awaited first!");
31385 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
31386 // debug statements here
31388 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
31390 export function RawInvoice_eq(a: number, b: number): boolean {
31391 if(!isWasmInitialized) {
31392 throw new Error("initializeWasm() must be awaited first!");
31394 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
31395 return nativeResponseValue;
31397 // uintptr_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
31399 export function RawInvoice_clone_ptr(arg: number): number {
31400 if(!isWasmInitialized) {
31401 throw new Error("initializeWasm() must be awaited first!");
31403 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
31404 return nativeResponseValue;
31406 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
31408 export function RawInvoice_clone(orig: number): number {
31409 if(!isWasmInitialized) {
31410 throw new Error("initializeWasm() must be awaited first!");
31412 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
31413 return nativeResponseValue;
31415 // void RawDataPart_free(struct LDKRawDataPart this_obj);
31417 export function RawDataPart_free(this_obj: number): void {
31418 if(!isWasmInitialized) {
31419 throw new Error("initializeWasm() must be awaited first!");
31421 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
31422 // debug statements here
31424 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
31426 export function RawDataPart_get_timestamp(this_ptr: number): number {
31427 if(!isWasmInitialized) {
31428 throw new Error("initializeWasm() must be awaited first!");
31430 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
31431 return nativeResponseValue;
31433 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
31435 export function RawDataPart_set_timestamp(this_ptr: number, val: number): void {
31436 if(!isWasmInitialized) {
31437 throw new Error("initializeWasm() must be awaited first!");
31439 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
31440 // debug statements here
31442 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
31444 export function RawDataPart_eq(a: number, b: number): boolean {
31445 if(!isWasmInitialized) {
31446 throw new Error("initializeWasm() must be awaited first!");
31448 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
31449 return nativeResponseValue;
31451 // uintptr_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
31453 export function RawDataPart_clone_ptr(arg: number): number {
31454 if(!isWasmInitialized) {
31455 throw new Error("initializeWasm() must be awaited first!");
31457 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
31458 return nativeResponseValue;
31460 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
31462 export function RawDataPart_clone(orig: number): number {
31463 if(!isWasmInitialized) {
31464 throw new Error("initializeWasm() must be awaited first!");
31466 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
31467 return nativeResponseValue;
31469 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
31471 export function PositiveTimestamp_free(this_obj: number): void {
31472 if(!isWasmInitialized) {
31473 throw new Error("initializeWasm() must be awaited first!");
31475 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
31476 // debug statements here
31478 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
31480 export function PositiveTimestamp_eq(a: number, b: number): boolean {
31481 if(!isWasmInitialized) {
31482 throw new Error("initializeWasm() must be awaited first!");
31484 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
31485 return nativeResponseValue;
31487 // uintptr_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
31489 export function PositiveTimestamp_clone_ptr(arg: number): number {
31490 if(!isWasmInitialized) {
31491 throw new Error("initializeWasm() must be awaited first!");
31493 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
31494 return nativeResponseValue;
31496 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
31498 export function PositiveTimestamp_clone(orig: number): number {
31499 if(!isWasmInitialized) {
31500 throw new Error("initializeWasm() must be awaited first!");
31502 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
31503 return nativeResponseValue;
31505 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
31507 export function SiPrefix_clone(orig: number): SiPrefix {
31508 if(!isWasmInitialized) {
31509 throw new Error("initializeWasm() must be awaited first!");
31511 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
31512 return nativeResponseValue;
31514 // enum LDKSiPrefix SiPrefix_milli(void);
31516 export function SiPrefix_milli(): SiPrefix {
31517 if(!isWasmInitialized) {
31518 throw new Error("initializeWasm() must be awaited first!");
31520 const nativeResponseValue = wasm.TS_SiPrefix_milli();
31521 return nativeResponseValue;
31523 // enum LDKSiPrefix SiPrefix_micro(void);
31525 export function SiPrefix_micro(): SiPrefix {
31526 if(!isWasmInitialized) {
31527 throw new Error("initializeWasm() must be awaited first!");
31529 const nativeResponseValue = wasm.TS_SiPrefix_micro();
31530 return nativeResponseValue;
31532 // enum LDKSiPrefix SiPrefix_nano(void);
31534 export function SiPrefix_nano(): SiPrefix {
31535 if(!isWasmInitialized) {
31536 throw new Error("initializeWasm() must be awaited first!");
31538 const nativeResponseValue = wasm.TS_SiPrefix_nano();
31539 return nativeResponseValue;
31541 // enum LDKSiPrefix SiPrefix_pico(void);
31543 export function SiPrefix_pico(): SiPrefix {
31544 if(!isWasmInitialized) {
31545 throw new Error("initializeWasm() must be awaited first!");
31547 const nativeResponseValue = wasm.TS_SiPrefix_pico();
31548 return nativeResponseValue;
31550 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
31552 export function SiPrefix_eq(a: number, b: number): boolean {
31553 if(!isWasmInitialized) {
31554 throw new Error("initializeWasm() must be awaited first!");
31556 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
31557 return nativeResponseValue;
31559 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
31561 export function SiPrefix_multiplier(this_arg: number): bigint {
31562 if(!isWasmInitialized) {
31563 throw new Error("initializeWasm() must be awaited first!");
31565 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
31566 return nativeResponseValue;
31568 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
31570 export function Currency_clone(orig: number): Currency {
31571 if(!isWasmInitialized) {
31572 throw new Error("initializeWasm() must be awaited first!");
31574 const nativeResponseValue = wasm.TS_Currency_clone(orig);
31575 return nativeResponseValue;
31577 // enum LDKCurrency Currency_bitcoin(void);
31579 export function Currency_bitcoin(): Currency {
31580 if(!isWasmInitialized) {
31581 throw new Error("initializeWasm() must be awaited first!");
31583 const nativeResponseValue = wasm.TS_Currency_bitcoin();
31584 return nativeResponseValue;
31586 // enum LDKCurrency Currency_bitcoin_testnet(void);
31588 export function Currency_bitcoin_testnet(): Currency {
31589 if(!isWasmInitialized) {
31590 throw new Error("initializeWasm() must be awaited first!");
31592 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
31593 return nativeResponseValue;
31595 // enum LDKCurrency Currency_regtest(void);
31597 export function Currency_regtest(): Currency {
31598 if(!isWasmInitialized) {
31599 throw new Error("initializeWasm() must be awaited first!");
31601 const nativeResponseValue = wasm.TS_Currency_regtest();
31602 return nativeResponseValue;
31604 // enum LDKCurrency Currency_simnet(void);
31606 export function Currency_simnet(): Currency {
31607 if(!isWasmInitialized) {
31608 throw new Error("initializeWasm() must be awaited first!");
31610 const nativeResponseValue = wasm.TS_Currency_simnet();
31611 return nativeResponseValue;
31613 // enum LDKCurrency Currency_signet(void);
31615 export function Currency_signet(): Currency {
31616 if(!isWasmInitialized) {
31617 throw new Error("initializeWasm() must be awaited first!");
31619 const nativeResponseValue = wasm.TS_Currency_signet();
31620 return nativeResponseValue;
31622 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
31624 export function Currency_hash(o: number): bigint {
31625 if(!isWasmInitialized) {
31626 throw new Error("initializeWasm() must be awaited first!");
31628 const nativeResponseValue = wasm.TS_Currency_hash(o);
31629 return nativeResponseValue;
31631 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
31633 export function Currency_eq(a: number, b: number): boolean {
31634 if(!isWasmInitialized) {
31635 throw new Error("initializeWasm() must be awaited first!");
31637 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
31638 return nativeResponseValue;
31640 // void Sha256_free(struct LDKSha256 this_obj);
31642 export function Sha256_free(this_obj: number): void {
31643 if(!isWasmInitialized) {
31644 throw new Error("initializeWasm() must be awaited first!");
31646 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
31647 // debug statements here
31649 // uintptr_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
31651 export function Sha256_clone_ptr(arg: number): number {
31652 if(!isWasmInitialized) {
31653 throw new Error("initializeWasm() must be awaited first!");
31655 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
31656 return nativeResponseValue;
31658 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
31660 export function Sha256_clone(orig: number): number {
31661 if(!isWasmInitialized) {
31662 throw new Error("initializeWasm() must be awaited first!");
31664 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
31665 return nativeResponseValue;
31667 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
31669 export function Sha256_hash(o: number): bigint {
31670 if(!isWasmInitialized) {
31671 throw new Error("initializeWasm() must be awaited first!");
31673 const nativeResponseValue = wasm.TS_Sha256_hash(o);
31674 return nativeResponseValue;
31676 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
31678 export function Sha256_eq(a: number, b: number): boolean {
31679 if(!isWasmInitialized) {
31680 throw new Error("initializeWasm() must be awaited first!");
31682 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
31683 return nativeResponseValue;
31685 // void Description_free(struct LDKDescription this_obj);
31687 export function Description_free(this_obj: number): void {
31688 if(!isWasmInitialized) {
31689 throw new Error("initializeWasm() must be awaited first!");
31691 const nativeResponseValue = wasm.TS_Description_free(this_obj);
31692 // debug statements here
31694 // uintptr_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
31696 export function Description_clone_ptr(arg: number): number {
31697 if(!isWasmInitialized) {
31698 throw new Error("initializeWasm() must be awaited first!");
31700 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
31701 return nativeResponseValue;
31703 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
31705 export function Description_clone(orig: number): number {
31706 if(!isWasmInitialized) {
31707 throw new Error("initializeWasm() must be awaited first!");
31709 const nativeResponseValue = wasm.TS_Description_clone(orig);
31710 return nativeResponseValue;
31712 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
31714 export function Description_hash(o: number): bigint {
31715 if(!isWasmInitialized) {
31716 throw new Error("initializeWasm() must be awaited first!");
31718 const nativeResponseValue = wasm.TS_Description_hash(o);
31719 return nativeResponseValue;
31721 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
31723 export function Description_eq(a: number, b: number): boolean {
31724 if(!isWasmInitialized) {
31725 throw new Error("initializeWasm() must be awaited first!");
31727 const nativeResponseValue = wasm.TS_Description_eq(a, b);
31728 return nativeResponseValue;
31730 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
31732 export function PayeePubKey_free(this_obj: number): void {
31733 if(!isWasmInitialized) {
31734 throw new Error("initializeWasm() must be awaited first!");
31736 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
31737 // debug statements here
31739 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
31741 export function PayeePubKey_get_a(this_ptr: number): number {
31742 if(!isWasmInitialized) {
31743 throw new Error("initializeWasm() must be awaited first!");
31745 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
31746 return nativeResponseValue;
31748 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31750 export function PayeePubKey_set_a(this_ptr: number, val: number): void {
31751 if(!isWasmInitialized) {
31752 throw new Error("initializeWasm() must be awaited first!");
31754 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
31755 // debug statements here
31757 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
31759 export function PayeePubKey_new(a_arg: number): number {
31760 if(!isWasmInitialized) {
31761 throw new Error("initializeWasm() must be awaited first!");
31763 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
31764 return nativeResponseValue;
31766 // uintptr_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
31768 export function PayeePubKey_clone_ptr(arg: number): number {
31769 if(!isWasmInitialized) {
31770 throw new Error("initializeWasm() must be awaited first!");
31772 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
31773 return nativeResponseValue;
31775 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
31777 export function PayeePubKey_clone(orig: number): number {
31778 if(!isWasmInitialized) {
31779 throw new Error("initializeWasm() must be awaited first!");
31781 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
31782 return nativeResponseValue;
31784 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
31786 export function PayeePubKey_hash(o: number): bigint {
31787 if(!isWasmInitialized) {
31788 throw new Error("initializeWasm() must be awaited first!");
31790 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
31791 return nativeResponseValue;
31793 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
31795 export function PayeePubKey_eq(a: number, b: number): boolean {
31796 if(!isWasmInitialized) {
31797 throw new Error("initializeWasm() must be awaited first!");
31799 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
31800 return nativeResponseValue;
31802 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
31804 export function ExpiryTime_free(this_obj: number): void {
31805 if(!isWasmInitialized) {
31806 throw new Error("initializeWasm() must be awaited first!");
31808 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
31809 // debug statements here
31811 // uintptr_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
31813 export function ExpiryTime_clone_ptr(arg: number): number {
31814 if(!isWasmInitialized) {
31815 throw new Error("initializeWasm() must be awaited first!");
31817 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
31818 return nativeResponseValue;
31820 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
31822 export function ExpiryTime_clone(orig: number): number {
31823 if(!isWasmInitialized) {
31824 throw new Error("initializeWasm() must be awaited first!");
31826 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
31827 return nativeResponseValue;
31829 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
31831 export function ExpiryTime_hash(o: number): bigint {
31832 if(!isWasmInitialized) {
31833 throw new Error("initializeWasm() must be awaited first!");
31835 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
31836 return nativeResponseValue;
31838 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
31840 export function ExpiryTime_eq(a: number, b: number): boolean {
31841 if(!isWasmInitialized) {
31842 throw new Error("initializeWasm() must be awaited first!");
31844 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
31845 return nativeResponseValue;
31847 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
31849 export function MinFinalCltvExpiry_free(this_obj: number): void {
31850 if(!isWasmInitialized) {
31851 throw new Error("initializeWasm() must be awaited first!");
31853 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
31854 // debug statements here
31856 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
31858 export function MinFinalCltvExpiry_get_a(this_ptr: number): bigint {
31859 if(!isWasmInitialized) {
31860 throw new Error("initializeWasm() must be awaited first!");
31862 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
31863 return nativeResponseValue;
31865 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
31867 export function MinFinalCltvExpiry_set_a(this_ptr: number, val: bigint): void {
31868 if(!isWasmInitialized) {
31869 throw new Error("initializeWasm() must be awaited first!");
31871 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
31872 // debug statements here
31874 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
31876 export function MinFinalCltvExpiry_new(a_arg: bigint): number {
31877 if(!isWasmInitialized) {
31878 throw new Error("initializeWasm() must be awaited first!");
31880 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
31881 return nativeResponseValue;
31883 // uintptr_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
31885 export function MinFinalCltvExpiry_clone_ptr(arg: number): number {
31886 if(!isWasmInitialized) {
31887 throw new Error("initializeWasm() must be awaited first!");
31889 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
31890 return nativeResponseValue;
31892 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
31894 export function MinFinalCltvExpiry_clone(orig: number): number {
31895 if(!isWasmInitialized) {
31896 throw new Error("initializeWasm() must be awaited first!");
31898 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
31899 return nativeResponseValue;
31901 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
31903 export function MinFinalCltvExpiry_hash(o: number): bigint {
31904 if(!isWasmInitialized) {
31905 throw new Error("initializeWasm() must be awaited first!");
31907 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
31908 return nativeResponseValue;
31910 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
31912 export function MinFinalCltvExpiry_eq(a: number, b: number): boolean {
31913 if(!isWasmInitialized) {
31914 throw new Error("initializeWasm() must be awaited first!");
31916 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
31917 return nativeResponseValue;
31919 // void Fallback_free(struct LDKFallback this_ptr);
31921 export function Fallback_free(this_ptr: number): void {
31922 if(!isWasmInitialized) {
31923 throw new Error("initializeWasm() must be awaited first!");
31925 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
31926 // debug statements here
31928 // uintptr_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
31930 export function Fallback_clone_ptr(arg: number): number {
31931 if(!isWasmInitialized) {
31932 throw new Error("initializeWasm() must be awaited first!");
31934 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
31935 return nativeResponseValue;
31937 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
31939 export function Fallback_clone(orig: number): number {
31940 if(!isWasmInitialized) {
31941 throw new Error("initializeWasm() must be awaited first!");
31943 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
31944 return nativeResponseValue;
31946 // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
31948 export function Fallback_seg_wit_program(version: number, program: number): number {
31949 if(!isWasmInitialized) {
31950 throw new Error("initializeWasm() must be awaited first!");
31952 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
31953 return nativeResponseValue;
31955 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
31957 export function Fallback_pub_key_hash(a: number): number {
31958 if(!isWasmInitialized) {
31959 throw new Error("initializeWasm() must be awaited first!");
31961 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
31962 return nativeResponseValue;
31964 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
31966 export function Fallback_script_hash(a: number): number {
31967 if(!isWasmInitialized) {
31968 throw new Error("initializeWasm() must be awaited first!");
31970 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
31971 return nativeResponseValue;
31973 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
31975 export function Fallback_hash(o: number): bigint {
31976 if(!isWasmInitialized) {
31977 throw new Error("initializeWasm() must be awaited first!");
31979 const nativeResponseValue = wasm.TS_Fallback_hash(o);
31980 return nativeResponseValue;
31982 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
31984 export function Fallback_eq(a: number, b: number): boolean {
31985 if(!isWasmInitialized) {
31986 throw new Error("initializeWasm() must be awaited first!");
31988 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
31989 return nativeResponseValue;
31991 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
31993 export function InvoiceSignature_free(this_obj: number): void {
31994 if(!isWasmInitialized) {
31995 throw new Error("initializeWasm() must be awaited first!");
31997 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
31998 // debug statements here
32000 // uintptr_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
32002 export function InvoiceSignature_clone_ptr(arg: number): number {
32003 if(!isWasmInitialized) {
32004 throw new Error("initializeWasm() must be awaited first!");
32006 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
32007 return nativeResponseValue;
32009 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
32011 export function InvoiceSignature_clone(orig: number): number {
32012 if(!isWasmInitialized) {
32013 throw new Error("initializeWasm() must be awaited first!");
32015 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
32016 return nativeResponseValue;
32018 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
32020 export function InvoiceSignature_eq(a: number, b: number): boolean {
32021 if(!isWasmInitialized) {
32022 throw new Error("initializeWasm() must be awaited first!");
32024 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
32025 return nativeResponseValue;
32027 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
32029 export function PrivateRoute_free(this_obj: number): void {
32030 if(!isWasmInitialized) {
32031 throw new Error("initializeWasm() must be awaited first!");
32033 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
32034 // debug statements here
32036 // uintptr_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
32038 export function PrivateRoute_clone_ptr(arg: number): number {
32039 if(!isWasmInitialized) {
32040 throw new Error("initializeWasm() must be awaited first!");
32042 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
32043 return nativeResponseValue;
32045 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
32047 export function PrivateRoute_clone(orig: number): number {
32048 if(!isWasmInitialized) {
32049 throw new Error("initializeWasm() must be awaited first!");
32051 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
32052 return nativeResponseValue;
32054 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
32056 export function PrivateRoute_hash(o: number): bigint {
32057 if(!isWasmInitialized) {
32058 throw new Error("initializeWasm() must be awaited first!");
32060 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
32061 return nativeResponseValue;
32063 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
32065 export function PrivateRoute_eq(a: number, b: number): boolean {
32066 if(!isWasmInitialized) {
32067 throw new Error("initializeWasm() must be awaited first!");
32069 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
32070 return nativeResponseValue;
32072 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
32074 export function SignedRawInvoice_into_parts(this_arg: number): number {
32075 if(!isWasmInitialized) {
32076 throw new Error("initializeWasm() must be awaited first!");
32078 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
32079 return nativeResponseValue;
32081 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32083 export function SignedRawInvoice_raw_invoice(this_arg: number): number {
32084 if(!isWasmInitialized) {
32085 throw new Error("initializeWasm() must be awaited first!");
32087 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
32088 return nativeResponseValue;
32090 // MUST_USE_RES const uint8_t (*SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
32092 export function SignedRawInvoice_hash(this_arg: number): number {
32093 if(!isWasmInitialized) {
32094 throw new Error("initializeWasm() must be awaited first!");
32096 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(this_arg);
32097 return nativeResponseValue;
32099 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32101 export function SignedRawInvoice_signature(this_arg: number): number {
32102 if(!isWasmInitialized) {
32103 throw new Error("initializeWasm() must be awaited first!");
32105 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
32106 return nativeResponseValue;
32108 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32110 export function SignedRawInvoice_recover_payee_pub_key(this_arg: number): number {
32111 if(!isWasmInitialized) {
32112 throw new Error("initializeWasm() must be awaited first!");
32114 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
32115 return nativeResponseValue;
32117 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32119 export function SignedRawInvoice_check_signature(this_arg: number): boolean {
32120 if(!isWasmInitialized) {
32121 throw new Error("initializeWasm() must be awaited first!");
32123 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
32124 return nativeResponseValue;
32126 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32128 export function RawInvoice_hash(this_arg: number): number {
32129 if(!isWasmInitialized) {
32130 throw new Error("initializeWasm() must be awaited first!");
32132 const nativeResponseValue = wasm.TS_RawInvoice_hash(this_arg);
32133 return nativeResponseValue;
32135 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32137 export function RawInvoice_payment_hash(this_arg: number): number {
32138 if(!isWasmInitialized) {
32139 throw new Error("initializeWasm() must be awaited first!");
32141 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
32142 return nativeResponseValue;
32144 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32146 export function RawInvoice_description(this_arg: number): number {
32147 if(!isWasmInitialized) {
32148 throw new Error("initializeWasm() must be awaited first!");
32150 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
32151 return nativeResponseValue;
32153 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32155 export function RawInvoice_payee_pub_key(this_arg: number): number {
32156 if(!isWasmInitialized) {
32157 throw new Error("initializeWasm() must be awaited first!");
32159 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
32160 return nativeResponseValue;
32162 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32164 export function RawInvoice_description_hash(this_arg: number): number {
32165 if(!isWasmInitialized) {
32166 throw new Error("initializeWasm() must be awaited first!");
32168 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
32169 return nativeResponseValue;
32171 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32173 export function RawInvoice_expiry_time(this_arg: number): number {
32174 if(!isWasmInitialized) {
32175 throw new Error("initializeWasm() must be awaited first!");
32177 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
32178 return nativeResponseValue;
32180 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32182 export function RawInvoice_min_final_cltv_expiry(this_arg: number): number {
32183 if(!isWasmInitialized) {
32184 throw new Error("initializeWasm() must be awaited first!");
32186 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
32187 return nativeResponseValue;
32189 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32191 export function RawInvoice_payment_secret(this_arg: number): number {
32192 if(!isWasmInitialized) {
32193 throw new Error("initializeWasm() must be awaited first!");
32195 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
32196 return nativeResponseValue;
32198 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32200 export function RawInvoice_features(this_arg: number): number {
32201 if(!isWasmInitialized) {
32202 throw new Error("initializeWasm() must be awaited first!");
32204 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
32205 return nativeResponseValue;
32207 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32209 export function RawInvoice_private_routes(this_arg: number): number {
32210 if(!isWasmInitialized) {
32211 throw new Error("initializeWasm() must be awaited first!");
32213 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
32214 return nativeResponseValue;
32216 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32218 export function RawInvoice_amount_pico_btc(this_arg: number): number {
32219 if(!isWasmInitialized) {
32220 throw new Error("initializeWasm() must be awaited first!");
32222 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
32223 return nativeResponseValue;
32225 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32227 export function RawInvoice_currency(this_arg: number): Currency {
32228 if(!isWasmInitialized) {
32229 throw new Error("initializeWasm() must be awaited first!");
32231 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
32232 return nativeResponseValue;
32234 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
32236 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): number {
32237 if(!isWasmInitialized) {
32238 throw new Error("initializeWasm() must be awaited first!");
32240 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
32241 return nativeResponseValue;
32243 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
32245 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): number {
32246 if(!isWasmInitialized) {
32247 throw new Error("initializeWasm() must be awaited first!");
32249 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
32250 return nativeResponseValue;
32252 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
32254 export function PositiveTimestamp_as_unix_timestamp(this_arg: number): bigint {
32255 if(!isWasmInitialized) {
32256 throw new Error("initializeWasm() must be awaited first!");
32258 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
32259 return nativeResponseValue;
32261 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
32263 export function PositiveTimestamp_as_duration_since_epoch(this_arg: number): bigint {
32264 if(!isWasmInitialized) {
32265 throw new Error("initializeWasm() must be awaited first!");
32267 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
32268 return nativeResponseValue;
32270 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
32272 export function Invoice_into_signed_raw(this_arg: number): number {
32273 if(!isWasmInitialized) {
32274 throw new Error("initializeWasm() must be awaited first!");
32276 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
32277 return nativeResponseValue;
32279 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
32281 export function Invoice_check_signature(this_arg: number): number {
32282 if(!isWasmInitialized) {
32283 throw new Error("initializeWasm() must be awaited first!");
32285 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
32286 return nativeResponseValue;
32288 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
32290 export function Invoice_from_signed(signed_invoice: number): number {
32291 if(!isWasmInitialized) {
32292 throw new Error("initializeWasm() must be awaited first!");
32294 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
32295 return nativeResponseValue;
32297 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
32299 export function Invoice_duration_since_epoch(this_arg: number): bigint {
32300 if(!isWasmInitialized) {
32301 throw new Error("initializeWasm() must be awaited first!");
32303 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
32304 return nativeResponseValue;
32306 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
32308 export function Invoice_payment_hash(this_arg: number): number {
32309 if(!isWasmInitialized) {
32310 throw new Error("initializeWasm() must be awaited first!");
32312 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
32313 return nativeResponseValue;
32315 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
32317 export function Invoice_payee_pub_key(this_arg: number): number {
32318 if(!isWasmInitialized) {
32319 throw new Error("initializeWasm() must be awaited first!");
32321 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
32322 return nativeResponseValue;
32324 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
32326 export function Invoice_payment_secret(this_arg: number): number {
32327 if(!isWasmInitialized) {
32328 throw new Error("initializeWasm() must be awaited first!");
32330 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
32331 return nativeResponseValue;
32333 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
32335 export function Invoice_features(this_arg: number): number {
32336 if(!isWasmInitialized) {
32337 throw new Error("initializeWasm() must be awaited first!");
32339 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
32340 return nativeResponseValue;
32342 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
32344 export function Invoice_recover_payee_pub_key(this_arg: number): number {
32345 if(!isWasmInitialized) {
32346 throw new Error("initializeWasm() must be awaited first!");
32348 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
32349 return nativeResponseValue;
32351 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
32353 export function Invoice_expiry_time(this_arg: number): bigint {
32354 if(!isWasmInitialized) {
32355 throw new Error("initializeWasm() must be awaited first!");
32357 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
32358 return nativeResponseValue;
32360 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
32362 export function Invoice_would_expire(this_arg: number, at_time: bigint): boolean {
32363 if(!isWasmInitialized) {
32364 throw new Error("initializeWasm() must be awaited first!");
32366 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
32367 return nativeResponseValue;
32369 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
32371 export function Invoice_min_final_cltv_expiry(this_arg: number): bigint {
32372 if(!isWasmInitialized) {
32373 throw new Error("initializeWasm() must be awaited first!");
32375 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
32376 return nativeResponseValue;
32378 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
32380 export function Invoice_private_routes(this_arg: number): number {
32381 if(!isWasmInitialized) {
32382 throw new Error("initializeWasm() must be awaited first!");
32384 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
32385 return nativeResponseValue;
32387 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
32389 export function Invoice_route_hints(this_arg: number): number {
32390 if(!isWasmInitialized) {
32391 throw new Error("initializeWasm() must be awaited first!");
32393 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
32394 return nativeResponseValue;
32396 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
32398 export function Invoice_currency(this_arg: number): Currency {
32399 if(!isWasmInitialized) {
32400 throw new Error("initializeWasm() must be awaited first!");
32402 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
32403 return nativeResponseValue;
32405 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
32407 export function Invoice_amount_milli_satoshis(this_arg: number): number {
32408 if(!isWasmInitialized) {
32409 throw new Error("initializeWasm() must be awaited first!");
32411 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
32412 return nativeResponseValue;
32414 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
32416 export function Description_new(description: number): number {
32417 if(!isWasmInitialized) {
32418 throw new Error("initializeWasm() must be awaited first!");
32420 const nativeResponseValue = wasm.TS_Description_new(description);
32421 return nativeResponseValue;
32423 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
32425 export function Description_into_inner(this_arg: number): number {
32426 if(!isWasmInitialized) {
32427 throw new Error("initializeWasm() must be awaited first!");
32429 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
32430 return nativeResponseValue;
32432 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
32434 export function ExpiryTime_from_seconds(seconds: bigint): number {
32435 if(!isWasmInitialized) {
32436 throw new Error("initializeWasm() must be awaited first!");
32438 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
32439 return nativeResponseValue;
32441 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
32443 export function ExpiryTime_from_duration(duration: bigint): number {
32444 if(!isWasmInitialized) {
32445 throw new Error("initializeWasm() must be awaited first!");
32447 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
32448 return nativeResponseValue;
32450 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
32452 export function ExpiryTime_as_seconds(this_arg: number): bigint {
32453 if(!isWasmInitialized) {
32454 throw new Error("initializeWasm() must be awaited first!");
32456 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
32457 return nativeResponseValue;
32459 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
32461 export function ExpiryTime_as_duration(this_arg: number): bigint {
32462 if(!isWasmInitialized) {
32463 throw new Error("initializeWasm() must be awaited first!");
32465 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
32466 return nativeResponseValue;
32468 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
32470 export function PrivateRoute_new(hops: number): number {
32471 if(!isWasmInitialized) {
32472 throw new Error("initializeWasm() must be awaited first!");
32474 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
32475 return nativeResponseValue;
32477 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
32479 export function PrivateRoute_into_inner(this_arg: number): number {
32480 if(!isWasmInitialized) {
32481 throw new Error("initializeWasm() must be awaited first!");
32483 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
32484 return nativeResponseValue;
32486 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
32488 export function CreationError_clone(orig: number): CreationError {
32489 if(!isWasmInitialized) {
32490 throw new Error("initializeWasm() must be awaited first!");
32492 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
32493 return nativeResponseValue;
32495 // enum LDKCreationError CreationError_description_too_long(void);
32497 export function CreationError_description_too_long(): CreationError {
32498 if(!isWasmInitialized) {
32499 throw new Error("initializeWasm() must be awaited first!");
32501 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
32502 return nativeResponseValue;
32504 // enum LDKCreationError CreationError_route_too_long(void);
32506 export function CreationError_route_too_long(): CreationError {
32507 if(!isWasmInitialized) {
32508 throw new Error("initializeWasm() must be awaited first!");
32510 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
32511 return nativeResponseValue;
32513 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
32515 export function CreationError_timestamp_out_of_bounds(): CreationError {
32516 if(!isWasmInitialized) {
32517 throw new Error("initializeWasm() must be awaited first!");
32519 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
32520 return nativeResponseValue;
32522 // enum LDKCreationError CreationError_invalid_amount(void);
32524 export function CreationError_invalid_amount(): CreationError {
32525 if(!isWasmInitialized) {
32526 throw new Error("initializeWasm() must be awaited first!");
32528 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
32529 return nativeResponseValue;
32531 // enum LDKCreationError CreationError_missing_route_hints(void);
32533 export function CreationError_missing_route_hints(): CreationError {
32534 if(!isWasmInitialized) {
32535 throw new Error("initializeWasm() must be awaited first!");
32537 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
32538 return nativeResponseValue;
32540 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
32542 export function CreationError_eq(a: number, b: number): boolean {
32543 if(!isWasmInitialized) {
32544 throw new Error("initializeWasm() must be awaited first!");
32546 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
32547 return nativeResponseValue;
32549 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
32551 export function CreationError_to_str(o: number): number {
32552 if(!isWasmInitialized) {
32553 throw new Error("initializeWasm() must be awaited first!");
32555 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
32556 return nativeResponseValue;
32558 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
32560 export function SemanticError_clone(orig: number): SemanticError {
32561 if(!isWasmInitialized) {
32562 throw new Error("initializeWasm() must be awaited first!");
32564 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
32565 return nativeResponseValue;
32567 // enum LDKSemanticError SemanticError_no_payment_hash(void);
32569 export function SemanticError_no_payment_hash(): SemanticError {
32570 if(!isWasmInitialized) {
32571 throw new Error("initializeWasm() must be awaited first!");
32573 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
32574 return nativeResponseValue;
32576 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
32578 export function SemanticError_multiple_payment_hashes(): SemanticError {
32579 if(!isWasmInitialized) {
32580 throw new Error("initializeWasm() must be awaited first!");
32582 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
32583 return nativeResponseValue;
32585 // enum LDKSemanticError SemanticError_no_description(void);
32587 export function SemanticError_no_description(): SemanticError {
32588 if(!isWasmInitialized) {
32589 throw new Error("initializeWasm() must be awaited first!");
32591 const nativeResponseValue = wasm.TS_SemanticError_no_description();
32592 return nativeResponseValue;
32594 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
32596 export function SemanticError_multiple_descriptions(): SemanticError {
32597 if(!isWasmInitialized) {
32598 throw new Error("initializeWasm() must be awaited first!");
32600 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
32601 return nativeResponseValue;
32603 // enum LDKSemanticError SemanticError_no_payment_secret(void);
32605 export function SemanticError_no_payment_secret(): SemanticError {
32606 if(!isWasmInitialized) {
32607 throw new Error("initializeWasm() must be awaited first!");
32609 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
32610 return nativeResponseValue;
32612 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
32614 export function SemanticError_multiple_payment_secrets(): SemanticError {
32615 if(!isWasmInitialized) {
32616 throw new Error("initializeWasm() must be awaited first!");
32618 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
32619 return nativeResponseValue;
32621 // enum LDKSemanticError SemanticError_invalid_features(void);
32623 export function SemanticError_invalid_features(): SemanticError {
32624 if(!isWasmInitialized) {
32625 throw new Error("initializeWasm() must be awaited first!");
32627 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
32628 return nativeResponseValue;
32630 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
32632 export function SemanticError_invalid_recovery_id(): SemanticError {
32633 if(!isWasmInitialized) {
32634 throw new Error("initializeWasm() must be awaited first!");
32636 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
32637 return nativeResponseValue;
32639 // enum LDKSemanticError SemanticError_invalid_signature(void);
32641 export function SemanticError_invalid_signature(): SemanticError {
32642 if(!isWasmInitialized) {
32643 throw new Error("initializeWasm() must be awaited first!");
32645 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
32646 return nativeResponseValue;
32648 // enum LDKSemanticError SemanticError_imprecise_amount(void);
32650 export function SemanticError_imprecise_amount(): SemanticError {
32651 if(!isWasmInitialized) {
32652 throw new Error("initializeWasm() must be awaited first!");
32654 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
32655 return nativeResponseValue;
32657 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
32659 export function SemanticError_eq(a: number, b: number): boolean {
32660 if(!isWasmInitialized) {
32661 throw new Error("initializeWasm() must be awaited first!");
32663 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
32664 return nativeResponseValue;
32666 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
32668 export function SemanticError_to_str(o: number): number {
32669 if(!isWasmInitialized) {
32670 throw new Error("initializeWasm() must be awaited first!");
32672 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
32673 return nativeResponseValue;
32675 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
32677 export function SignOrCreationError_free(this_ptr: number): void {
32678 if(!isWasmInitialized) {
32679 throw new Error("initializeWasm() must be awaited first!");
32681 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
32682 // debug statements here
32684 // uintptr_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
32686 export function SignOrCreationError_clone_ptr(arg: number): number {
32687 if(!isWasmInitialized) {
32688 throw new Error("initializeWasm() must be awaited first!");
32690 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
32691 return nativeResponseValue;
32693 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
32695 export function SignOrCreationError_clone(orig: number): number {
32696 if(!isWasmInitialized) {
32697 throw new Error("initializeWasm() must be awaited first!");
32699 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
32700 return nativeResponseValue;
32702 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
32704 export function SignOrCreationError_sign_error(): number {
32705 if(!isWasmInitialized) {
32706 throw new Error("initializeWasm() must be awaited first!");
32708 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
32709 return nativeResponseValue;
32711 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
32713 export function SignOrCreationError_creation_error(a: CreationError): number {
32714 if(!isWasmInitialized) {
32715 throw new Error("initializeWasm() must be awaited first!");
32717 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
32718 return nativeResponseValue;
32720 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
32722 export function SignOrCreationError_eq(a: number, b: number): boolean {
32723 if(!isWasmInitialized) {
32724 throw new Error("initializeWasm() must be awaited first!");
32726 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
32727 return nativeResponseValue;
32729 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
32731 export function SignOrCreationError_to_str(o: number): number {
32732 if(!isWasmInitialized) {
32733 throw new Error("initializeWasm() must be awaited first!");
32735 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
32736 return nativeResponseValue;
32738 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
32740 export function InvoicePayer_free(this_obj: number): void {
32741 if(!isWasmInitialized) {
32742 throw new Error("initializeWasm() must be awaited first!");
32744 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
32745 // debug statements here
32747 // void Payer_free(struct LDKPayer this_ptr);
32749 export function Payer_free(this_ptr: number): void {
32750 if(!isWasmInitialized) {
32751 throw new Error("initializeWasm() must be awaited first!");
32753 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
32754 // debug statements here
32756 // void Router_free(struct LDKRouter this_ptr);
32758 export function Router_free(this_ptr: number): void {
32759 if(!isWasmInitialized) {
32760 throw new Error("initializeWasm() must be awaited first!");
32762 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
32763 // debug statements here
32765 // void Retry_free(struct LDKRetry this_ptr);
32767 export function Retry_free(this_ptr: number): void {
32768 if(!isWasmInitialized) {
32769 throw new Error("initializeWasm() must be awaited first!");
32771 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
32772 // debug statements here
32774 // uintptr_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
32776 export function Retry_clone_ptr(arg: number): number {
32777 if(!isWasmInitialized) {
32778 throw new Error("initializeWasm() must be awaited first!");
32780 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
32781 return nativeResponseValue;
32783 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
32785 export function Retry_clone(orig: number): number {
32786 if(!isWasmInitialized) {
32787 throw new Error("initializeWasm() must be awaited first!");
32789 const nativeResponseValue = wasm.TS_Retry_clone(orig);
32790 return nativeResponseValue;
32792 // struct LDKRetry Retry_attempts(uintptr_t a);
32794 export function Retry_attempts(a: number): number {
32795 if(!isWasmInitialized) {
32796 throw new Error("initializeWasm() must be awaited first!");
32798 const nativeResponseValue = wasm.TS_Retry_attempts(a);
32799 return nativeResponseValue;
32801 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
32803 export function Retry_eq(a: number, b: number): boolean {
32804 if(!isWasmInitialized) {
32805 throw new Error("initializeWasm() must be awaited first!");
32807 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
32808 return nativeResponseValue;
32810 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
32812 export function Retry_hash(o: number): bigint {
32813 if(!isWasmInitialized) {
32814 throw new Error("initializeWasm() must be awaited first!");
32816 const nativeResponseValue = wasm.TS_Retry_hash(o);
32817 return nativeResponseValue;
32819 // void PaymentError_free(struct LDKPaymentError this_ptr);
32821 export function PaymentError_free(this_ptr: number): void {
32822 if(!isWasmInitialized) {
32823 throw new Error("initializeWasm() must be awaited first!");
32825 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
32826 // debug statements here
32828 // uintptr_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
32830 export function PaymentError_clone_ptr(arg: number): number {
32831 if(!isWasmInitialized) {
32832 throw new Error("initializeWasm() must be awaited first!");
32834 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
32835 return nativeResponseValue;
32837 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
32839 export function PaymentError_clone(orig: number): number {
32840 if(!isWasmInitialized) {
32841 throw new Error("initializeWasm() must be awaited first!");
32843 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
32844 return nativeResponseValue;
32846 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
32848 export function PaymentError_invoice(a: number): number {
32849 if(!isWasmInitialized) {
32850 throw new Error("initializeWasm() must be awaited first!");
32852 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
32853 return nativeResponseValue;
32855 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
32857 export function PaymentError_routing(a: number): number {
32858 if(!isWasmInitialized) {
32859 throw new Error("initializeWasm() must be awaited first!");
32861 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
32862 return nativeResponseValue;
32864 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
32866 export function PaymentError_sending(a: number): number {
32867 if(!isWasmInitialized) {
32868 throw new Error("initializeWasm() must be awaited first!");
32870 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
32871 return nativeResponseValue;
32873 // 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);
32875 export function InvoicePayer_new(payer: number, router: number, scorer: number, logger: number, event_handler: number, retry: number): number {
32876 if(!isWasmInitialized) {
32877 throw new Error("initializeWasm() must be awaited first!");
32879 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, scorer, logger, event_handler, retry);
32880 return nativeResponseValue;
32882 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
32884 export function InvoicePayer_pay_invoice(this_arg: number, invoice: number): number {
32885 if(!isWasmInitialized) {
32886 throw new Error("initializeWasm() must be awaited first!");
32888 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
32889 return nativeResponseValue;
32891 // 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);
32893 export function InvoicePayer_pay_zero_value_invoice(this_arg: number, invoice: number, amount_msats: bigint): number {
32894 if(!isWasmInitialized) {
32895 throw new Error("initializeWasm() must be awaited first!");
32897 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
32898 return nativeResponseValue;
32900 // 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);
32902 export function InvoicePayer_pay_pubkey(this_arg: number, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): number {
32903 if(!isWasmInitialized) {
32904 throw new Error("initializeWasm() must be awaited first!");
32906 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
32907 return nativeResponseValue;
32909 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
32911 export function InvoicePayer_remove_cached_payment(this_arg: number, payment_hash: number): void {
32912 if(!isWasmInitialized) {
32913 throw new Error("initializeWasm() must be awaited first!");
32915 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
32916 // debug statements here
32918 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
32920 export function InvoicePayer_as_EventHandler(this_arg: number): number {
32921 if(!isWasmInitialized) {
32922 throw new Error("initializeWasm() must be awaited first!");
32924 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
32925 return nativeResponseValue;
32927 // 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);
32929 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 {
32930 if(!isWasmInitialized) {
32931 throw new Error("initializeWasm() must be awaited first!");
32933 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);
32934 return nativeResponseValue;
32936 // 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);
32938 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 {
32939 if(!isWasmInitialized) {
32940 throw new Error("initializeWasm() must be awaited first!");
32942 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);
32943 return nativeResponseValue;
32945 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
32947 export function DefaultRouter_free(this_obj: number): void {
32948 if(!isWasmInitialized) {
32949 throw new Error("initializeWasm() must be awaited first!");
32951 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
32952 // debug statements here
32954 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes);
32956 export function DefaultRouter_new(network_graph: number, logger: number, random_seed_bytes: number): number {
32957 if(!isWasmInitialized) {
32958 throw new Error("initializeWasm() must be awaited first!");
32960 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes);
32961 return nativeResponseValue;
32963 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
32965 export function DefaultRouter_as_Router(this_arg: number): number {
32966 if(!isWasmInitialized) {
32967 throw new Error("initializeWasm() must be awaited first!");
32969 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
32970 return nativeResponseValue;
32972 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
32974 export function ChannelManager_as_Payer(this_arg: number): number {
32975 if(!isWasmInitialized) {
32976 throw new Error("initializeWasm() must be awaited first!");
32978 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
32979 return nativeResponseValue;
32981 // struct LDKCResult_SiPrefixParseErrorZ SiPrefix_from_str(struct LDKStr s);
32983 export function SiPrefix_from_str(s: number): number {
32984 if(!isWasmInitialized) {
32985 throw new Error("initializeWasm() must be awaited first!");
32987 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
32988 return nativeResponseValue;
32990 // struct LDKCResult_InvoiceParseOrSemanticErrorZ Invoice_from_str(struct LDKStr s);
32992 export function Invoice_from_str(s: number): number {
32993 if(!isWasmInitialized) {
32994 throw new Error("initializeWasm() must be awaited first!");
32996 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
32997 return nativeResponseValue;
32999 // struct LDKCResult_SignedRawInvoiceParseErrorZ SignedRawInvoice_from_str(struct LDKStr s);
33001 export function SignedRawInvoice_from_str(s: number): number {
33002 if(!isWasmInitialized) {
33003 throw new Error("initializeWasm() must be awaited first!");
33005 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
33006 return nativeResponseValue;
33008 // struct LDKStr ParseError_to_str(const struct LDKParseError *NONNULL_PTR o);
33010 export function ParseError_to_str(o: number): number {
33011 if(!isWasmInitialized) {
33012 throw new Error("initializeWasm() must be awaited first!");
33014 const nativeResponseValue = wasm.TS_ParseError_to_str(o);
33015 return nativeResponseValue;
33017 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
33019 export function ParseOrSemanticError_to_str(o: number): number {
33020 if(!isWasmInitialized) {
33021 throw new Error("initializeWasm() must be awaited first!");
33023 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
33024 return nativeResponseValue;
33026 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
33028 export function Invoice_to_str(o: number): number {
33029 if(!isWasmInitialized) {
33030 throw new Error("initializeWasm() must be awaited first!");
33032 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
33033 return nativeResponseValue;
33035 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
33037 export function SignedRawInvoice_to_str(o: number): number {
33038 if(!isWasmInitialized) {
33039 throw new Error("initializeWasm() must be awaited first!");
33041 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
33042 return nativeResponseValue;
33044 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
33046 export function Currency_to_str(o: number): number {
33047 if(!isWasmInitialized) {
33048 throw new Error("initializeWasm() must be awaited first!");
33050 const nativeResponseValue = wasm.TS_Currency_to_str(o);
33051 return nativeResponseValue;
33053 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
33055 export function SiPrefix_to_str(o: number): number {
33056 if(!isWasmInitialized) {
33057 throw new Error("initializeWasm() must be awaited first!");
33059 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
33060 return nativeResponseValue;
33064 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) {
33065 const weak: WeakRef<object> = js_objs[obj_ptr];
33066 if (weak == null || weak == undefined) {
33067 console.error("Got function call on unknown/free'd JS object!");
33068 throw new Error("Got function call on unknown/free'd JS object!");
33070 const obj: object = weak.deref();
33071 if (obj == null || obj == undefined) {
33072 console.error("Got function call on GC'd JS object!");
33073 throw new Error("Got function call on GC'd JS object!");
33077 case 0: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
33078 case 1: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
33079 case 2: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
33080 case 3: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
33081 case 4: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
33082 case 5: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
33083 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
33084 case 7: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
33085 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
33086 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
33087 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
33088 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
33089 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
33090 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
33091 case 14: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
33092 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33093 case 16: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
33094 case 17: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
33095 case 18: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
33096 case 19: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
33097 case 20: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
33098 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
33099 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
33100 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
33101 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
33102 case 25: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
33103 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
33104 case 27: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
33105 case 28: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
33106 case 29: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
33107 case 30: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
33108 case 31: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33109 case 32: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
33110 case 33: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
33111 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
33112 case 35: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
33113 case 36: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
33114 case 37: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
33115 case 38: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
33116 case 39: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
33117 case 40: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33118 case 41: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
33119 case 42: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
33120 case 43: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
33121 case 44: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
33122 case 45: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
33123 case 46: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
33124 case 47: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
33125 case 48: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
33126 case 49: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
33127 case 50: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
33128 case 51: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
33129 case 52: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
33130 case 53: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
33131 case 54: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
33132 case 55: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
33133 case 56: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
33134 case 57: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
33135 case 58: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
33136 case 59: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
33137 case 60: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
33138 case 61: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
33139 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
33140 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
33141 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
33142 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
33143 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
33144 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
33145 case 68: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
33146 case 69: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
33147 case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
33148 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
33149 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
33150 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
33151 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
33152 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
33153 case 76: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcements"); break;
33154 case 77: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcements"); break;
33155 case 78: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
33156 case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
33157 case 80: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
33158 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
33159 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
33160 case 83: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
33161 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
33162 case 85: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
33163 case 86: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
33164 case 87: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
33165 case 88: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
33166 case 89: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
33167 case 90: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
33168 case 91: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
33169 case 92: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
33170 case 93: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
33171 case 94: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
33172 case 95: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
33173 case 96: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
33174 case 97: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
33176 console.error("Got unknown function call from C!");
33177 throw new Error("Got unknown function call from C!");
33179 if (fn == null || fn == undefined) {
33180 console.error("Got function call on incorrect JS object!");
33181 throw new Error("Got function call on incorrect JS object!");
33183 const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
33184 if (ret === undefined || ret === null) return BigInt(0);
33185 return BigInt(ret);