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 LDKHTLCDestination {
1288 protected constructor() {}
1291 export function LDKHTLCDestination_ty_from_ptr(ptr: number): number {
1292 if(!isWasmInitialized) {
1293 throw new Error("initializeWasm() must be awaited first!");
1295 const nativeResponseValue = wasm.TS_LDKHTLCDestination_ty_from_ptr(ptr);
1296 return nativeResponseValue;
1299 export function LDKHTLCDestination_NextHopChannel_get_node_id(ptr: number): number {
1300 if(!isWasmInitialized) {
1301 throw new Error("initializeWasm() must be awaited first!");
1303 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_node_id(ptr);
1304 return nativeResponseValue;
1307 export function LDKHTLCDestination_NextHopChannel_get_channel_id(ptr: number): number {
1308 if(!isWasmInitialized) {
1309 throw new Error("initializeWasm() must be awaited first!");
1311 const nativeResponseValue = wasm.TS_LDKHTLCDestination_NextHopChannel_get_channel_id(ptr);
1312 return nativeResponseValue;
1315 export function LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr: number): bigint {
1316 if(!isWasmInitialized) {
1317 throw new Error("initializeWasm() must be awaited first!");
1319 const nativeResponseValue = wasm.TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(ptr);
1320 return nativeResponseValue;
1323 export function LDKHTLCDestination_FailedPayment_get_payment_hash(ptr: number): number {
1324 if(!isWasmInitialized) {
1325 throw new Error("initializeWasm() must be awaited first!");
1327 const nativeResponseValue = wasm.TS_LDKHTLCDestination_FailedPayment_get_payment_hash(ptr);
1328 return nativeResponseValue;
1331 export class LDKCOption_HTLCDestinationZ {
1332 protected constructor() {}
1335 export function LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr: number): number {
1336 if(!isWasmInitialized) {
1337 throw new Error("initializeWasm() must be awaited first!");
1339 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(ptr);
1340 return nativeResponseValue;
1343 export function LDKCOption_HTLCDestinationZ_Some_get_some(ptr: number): number {
1344 if(!isWasmInitialized) {
1345 throw new Error("initializeWasm() must be awaited first!");
1347 const nativeResponseValue = wasm.TS_LDKCOption_HTLCDestinationZ_Some_get_some(ptr);
1348 return nativeResponseValue;
1350 // struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1352 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner: number): number {
1353 if(!isWasmInitialized) {
1354 throw new Error("initializeWasm() must be awaited first!");
1356 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner);
1357 return nativeResponseValue;
1359 // struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner);
1361 export function CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner: number): number {
1362 if(!isWasmInitialized) {
1363 throw new Error("initializeWasm() must be awaited first!");
1365 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner);
1366 return nativeResponseValue;
1369 export class LDKNetworkUpdate {
1370 protected constructor() {}
1373 export function LDKNetworkUpdate_ty_from_ptr(ptr: number): number {
1374 if(!isWasmInitialized) {
1375 throw new Error("initializeWasm() must be awaited first!");
1377 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1378 return nativeResponseValue;
1381 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: number): number {
1382 if(!isWasmInitialized) {
1383 throw new Error("initializeWasm() must be awaited first!");
1385 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1386 return nativeResponseValue;
1389 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: number): bigint {
1390 if(!isWasmInitialized) {
1391 throw new Error("initializeWasm() must be awaited first!");
1393 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
1394 return nativeResponseValue;
1397 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: number): boolean {
1398 if(!isWasmInitialized) {
1399 throw new Error("initializeWasm() must be awaited first!");
1401 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
1402 return nativeResponseValue;
1405 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: number): number {
1406 if(!isWasmInitialized) {
1407 throw new Error("initializeWasm() must be awaited first!");
1409 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1410 return nativeResponseValue;
1413 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: number): boolean {
1414 if(!isWasmInitialized) {
1415 throw new Error("initializeWasm() must be awaited first!");
1417 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1418 return nativeResponseValue;
1421 export class LDKCOption_NetworkUpdateZ {
1422 protected constructor() {}
1425 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: number): number {
1426 if(!isWasmInitialized) {
1427 throw new Error("initializeWasm() must be awaited first!");
1429 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1430 return nativeResponseValue;
1433 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: number): number {
1434 if(!isWasmInitialized) {
1435 throw new Error("initializeWasm() must be awaited first!");
1437 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1438 return nativeResponseValue;
1441 export class LDKSpendableOutputDescriptor {
1442 protected constructor() {}
1445 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: number): number {
1446 if(!isWasmInitialized) {
1447 throw new Error("initializeWasm() must be awaited first!");
1449 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1450 return nativeResponseValue;
1453 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: number): number {
1454 if(!isWasmInitialized) {
1455 throw new Error("initializeWasm() must be awaited first!");
1457 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1458 return nativeResponseValue;
1461 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: number): number {
1462 if(!isWasmInitialized) {
1463 throw new Error("initializeWasm() must be awaited first!");
1465 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1466 return nativeResponseValue;
1469 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: number): number {
1470 if(!isWasmInitialized) {
1471 throw new Error("initializeWasm() must be awaited first!");
1473 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1474 return nativeResponseValue;
1477 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: number): number {
1478 if(!isWasmInitialized) {
1479 throw new Error("initializeWasm() must be awaited first!");
1481 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1482 return nativeResponseValue;
1485 export class LDKEvent {
1486 protected constructor() {}
1489 export function LDKEvent_ty_from_ptr(ptr: number): number {
1490 if(!isWasmInitialized) {
1491 throw new Error("initializeWasm() must be awaited first!");
1493 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1494 return nativeResponseValue;
1497 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: number): number {
1498 if(!isWasmInitialized) {
1499 throw new Error("initializeWasm() must be awaited first!");
1501 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1502 return nativeResponseValue;
1505 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: number): number {
1506 if(!isWasmInitialized) {
1507 throw new Error("initializeWasm() must be awaited first!");
1509 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
1510 return nativeResponseValue;
1513 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: number): bigint {
1514 if(!isWasmInitialized) {
1515 throw new Error("initializeWasm() must be awaited first!");
1517 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1518 return nativeResponseValue;
1521 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: number): number {
1522 if(!isWasmInitialized) {
1523 throw new Error("initializeWasm() must be awaited first!");
1525 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1526 return nativeResponseValue;
1529 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: number): bigint {
1530 if(!isWasmInitialized) {
1531 throw new Error("initializeWasm() must be awaited first!");
1533 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1534 return nativeResponseValue;
1537 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: number): number {
1538 if(!isWasmInitialized) {
1539 throw new Error("initializeWasm() must be awaited first!");
1541 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1542 return nativeResponseValue;
1545 export function LDKEvent_PaymentReceived_get_amount_msat(ptr: number): bigint {
1546 if(!isWasmInitialized) {
1547 throw new Error("initializeWasm() must be awaited first!");
1549 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amount_msat(ptr);
1550 return nativeResponseValue;
1553 export function LDKEvent_PaymentReceived_get_purpose(ptr: number): number {
1554 if(!isWasmInitialized) {
1555 throw new Error("initializeWasm() must be awaited first!");
1557 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1558 return nativeResponseValue;
1561 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: number): number {
1562 if(!isWasmInitialized) {
1563 throw new Error("initializeWasm() must be awaited first!");
1565 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
1566 return nativeResponseValue;
1569 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: number): bigint {
1570 if(!isWasmInitialized) {
1571 throw new Error("initializeWasm() must be awaited first!");
1573 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
1574 return nativeResponseValue;
1577 export function LDKEvent_PaymentClaimed_get_purpose(ptr: number): number {
1578 if(!isWasmInitialized) {
1579 throw new Error("initializeWasm() must be awaited first!");
1581 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
1582 return nativeResponseValue;
1585 export function LDKEvent_PaymentSent_get_payment_id(ptr: number): number {
1586 if(!isWasmInitialized) {
1587 throw new Error("initializeWasm() must be awaited first!");
1589 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1590 return nativeResponseValue;
1593 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: number): number {
1594 if(!isWasmInitialized) {
1595 throw new Error("initializeWasm() must be awaited first!");
1597 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1598 return nativeResponseValue;
1601 export function LDKEvent_PaymentSent_get_payment_hash(ptr: number): number {
1602 if(!isWasmInitialized) {
1603 throw new Error("initializeWasm() must be awaited first!");
1605 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1606 return nativeResponseValue;
1609 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: number): number {
1610 if(!isWasmInitialized) {
1611 throw new Error("initializeWasm() must be awaited first!");
1613 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1614 return nativeResponseValue;
1617 export function LDKEvent_PaymentFailed_get_payment_id(ptr: number): number {
1618 if(!isWasmInitialized) {
1619 throw new Error("initializeWasm() must be awaited first!");
1621 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1622 return nativeResponseValue;
1625 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: number): number {
1626 if(!isWasmInitialized) {
1627 throw new Error("initializeWasm() must be awaited first!");
1629 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1630 return nativeResponseValue;
1633 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: number): number {
1634 if(!isWasmInitialized) {
1635 throw new Error("initializeWasm() must be awaited first!");
1637 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1638 return nativeResponseValue;
1641 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: number): number {
1642 if(!isWasmInitialized) {
1643 throw new Error("initializeWasm() must be awaited first!");
1645 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1646 return nativeResponseValue;
1649 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: number): number {
1650 if(!isWasmInitialized) {
1651 throw new Error("initializeWasm() must be awaited first!");
1653 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1654 return nativeResponseValue;
1657 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: number): number {
1658 if(!isWasmInitialized) {
1659 throw new Error("initializeWasm() must be awaited first!");
1661 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1662 return nativeResponseValue;
1665 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: number): number {
1666 if(!isWasmInitialized) {
1667 throw new Error("initializeWasm() must be awaited first!");
1669 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1670 return nativeResponseValue;
1673 export function LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr: number): boolean {
1674 if(!isWasmInitialized) {
1675 throw new Error("initializeWasm() must be awaited first!");
1677 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr);
1678 return nativeResponseValue;
1681 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: number): number {
1682 if(!isWasmInitialized) {
1683 throw new Error("initializeWasm() must be awaited first!");
1685 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1686 return nativeResponseValue;
1689 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: number): boolean {
1690 if(!isWasmInitialized) {
1691 throw new Error("initializeWasm() must be awaited first!");
1693 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1694 return nativeResponseValue;
1697 export function LDKEvent_PaymentPathFailed_get_path(ptr: number): number {
1698 if(!isWasmInitialized) {
1699 throw new Error("initializeWasm() must be awaited first!");
1701 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1702 return nativeResponseValue;
1705 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: number): number {
1706 if(!isWasmInitialized) {
1707 throw new Error("initializeWasm() must be awaited first!");
1709 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1710 return nativeResponseValue;
1713 export function LDKEvent_PaymentPathFailed_get_retry(ptr: number): number {
1714 if(!isWasmInitialized) {
1715 throw new Error("initializeWasm() must be awaited first!");
1717 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1718 return nativeResponseValue;
1721 export function LDKEvent_ProbeSuccessful_get_payment_id(ptr: number): number {
1722 if(!isWasmInitialized) {
1723 throw new Error("initializeWasm() must be awaited first!");
1725 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_id(ptr);
1726 return nativeResponseValue;
1729 export function LDKEvent_ProbeSuccessful_get_payment_hash(ptr: number): number {
1730 if(!isWasmInitialized) {
1731 throw new Error("initializeWasm() must be awaited first!");
1733 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_payment_hash(ptr);
1734 return nativeResponseValue;
1737 export function LDKEvent_ProbeSuccessful_get_path(ptr: number): number {
1738 if(!isWasmInitialized) {
1739 throw new Error("initializeWasm() must be awaited first!");
1741 const nativeResponseValue = wasm.TS_LDKEvent_ProbeSuccessful_get_path(ptr);
1742 return nativeResponseValue;
1745 export function LDKEvent_ProbeFailed_get_payment_id(ptr: number): number {
1746 if(!isWasmInitialized) {
1747 throw new Error("initializeWasm() must be awaited first!");
1749 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_id(ptr);
1750 return nativeResponseValue;
1753 export function LDKEvent_ProbeFailed_get_payment_hash(ptr: number): number {
1754 if(!isWasmInitialized) {
1755 throw new Error("initializeWasm() must be awaited first!");
1757 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_payment_hash(ptr);
1758 return nativeResponseValue;
1761 export function LDKEvent_ProbeFailed_get_path(ptr: number): number {
1762 if(!isWasmInitialized) {
1763 throw new Error("initializeWasm() must be awaited first!");
1765 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_path(ptr);
1766 return nativeResponseValue;
1769 export function LDKEvent_ProbeFailed_get_short_channel_id(ptr: number): number {
1770 if(!isWasmInitialized) {
1771 throw new Error("initializeWasm() must be awaited first!");
1773 const nativeResponseValue = wasm.TS_LDKEvent_ProbeFailed_get_short_channel_id(ptr);
1774 return nativeResponseValue;
1777 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: number): bigint {
1778 if(!isWasmInitialized) {
1779 throw new Error("initializeWasm() must be awaited first!");
1781 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1782 return nativeResponseValue;
1785 export function LDKEvent_SpendableOutputs_get_outputs(ptr: number): number {
1786 if(!isWasmInitialized) {
1787 throw new Error("initializeWasm() must be awaited first!");
1789 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1790 return nativeResponseValue;
1793 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: number): number {
1794 if(!isWasmInitialized) {
1795 throw new Error("initializeWasm() must be awaited first!");
1797 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
1798 return nativeResponseValue;
1801 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: number): number {
1802 if(!isWasmInitialized) {
1803 throw new Error("initializeWasm() must be awaited first!");
1805 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
1806 return nativeResponseValue;
1809 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: number): number {
1810 if(!isWasmInitialized) {
1811 throw new Error("initializeWasm() must be awaited first!");
1813 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1814 return nativeResponseValue;
1817 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: number): boolean {
1818 if(!isWasmInitialized) {
1819 throw new Error("initializeWasm() must be awaited first!");
1821 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1822 return nativeResponseValue;
1825 export function LDKEvent_ChannelClosed_get_channel_id(ptr: number): number {
1826 if(!isWasmInitialized) {
1827 throw new Error("initializeWasm() must be awaited first!");
1829 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1830 return nativeResponseValue;
1833 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: number): bigint {
1834 if(!isWasmInitialized) {
1835 throw new Error("initializeWasm() must be awaited first!");
1837 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1838 return nativeResponseValue;
1841 export function LDKEvent_ChannelClosed_get_reason(ptr: number): number {
1842 if(!isWasmInitialized) {
1843 throw new Error("initializeWasm() must be awaited first!");
1845 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1846 return nativeResponseValue;
1849 export function LDKEvent_DiscardFunding_get_channel_id(ptr: number): number {
1850 if(!isWasmInitialized) {
1851 throw new Error("initializeWasm() must be awaited first!");
1853 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1854 return nativeResponseValue;
1857 export function LDKEvent_DiscardFunding_get_transaction(ptr: number): number {
1858 if(!isWasmInitialized) {
1859 throw new Error("initializeWasm() must be awaited first!");
1861 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
1862 return nativeResponseValue;
1865 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: number): number {
1866 if(!isWasmInitialized) {
1867 throw new Error("initializeWasm() must be awaited first!");
1869 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
1870 return nativeResponseValue;
1873 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: number): number {
1874 if(!isWasmInitialized) {
1875 throw new Error("initializeWasm() must be awaited first!");
1877 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
1878 return nativeResponseValue;
1881 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: number): bigint {
1882 if(!isWasmInitialized) {
1883 throw new Error("initializeWasm() must be awaited first!");
1885 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
1886 return nativeResponseValue;
1889 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: number): bigint {
1890 if(!isWasmInitialized) {
1891 throw new Error("initializeWasm() must be awaited first!");
1893 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
1894 return nativeResponseValue;
1897 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: number): number {
1898 if(!isWasmInitialized) {
1899 throw new Error("initializeWasm() must be awaited first!");
1901 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
1902 return nativeResponseValue;
1905 export function LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr: number): number {
1906 if(!isWasmInitialized) {
1907 throw new Error("initializeWasm() must be awaited first!");
1909 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(ptr);
1910 return nativeResponseValue;
1913 export function LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr: number): number {
1914 if(!isWasmInitialized) {
1915 throw new Error("initializeWasm() must be awaited first!");
1917 const nativeResponseValue = wasm.TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(ptr);
1918 return nativeResponseValue;
1921 export class LDKCOption_EventZ {
1922 protected constructor() {}
1925 export function LDKCOption_EventZ_ty_from_ptr(ptr: number): number {
1926 if(!isWasmInitialized) {
1927 throw new Error("initializeWasm() must be awaited first!");
1929 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
1930 return nativeResponseValue;
1933 export function LDKCOption_EventZ_Some_get_some(ptr: number): number {
1934 if(!isWasmInitialized) {
1935 throw new Error("initializeWasm() must be awaited first!");
1937 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
1938 return nativeResponseValue;
1940 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1942 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: number): number {
1943 if(!isWasmInitialized) {
1944 throw new Error("initializeWasm() must be awaited first!");
1946 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
1947 return nativeResponseValue;
1949 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1951 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: number): number {
1952 if(!isWasmInitialized) {
1953 throw new Error("initializeWasm() must be awaited first!");
1955 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
1956 return nativeResponseValue;
1959 export class LDKErrorAction {
1960 protected constructor() {}
1963 export function LDKErrorAction_ty_from_ptr(ptr: number): number {
1964 if(!isWasmInitialized) {
1965 throw new Error("initializeWasm() must be awaited first!");
1967 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
1968 return nativeResponseValue;
1971 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: number): number {
1972 if(!isWasmInitialized) {
1973 throw new Error("initializeWasm() must be awaited first!");
1975 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
1976 return nativeResponseValue;
1979 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: number): Level {
1980 if(!isWasmInitialized) {
1981 throw new Error("initializeWasm() must be awaited first!");
1983 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
1984 return nativeResponseValue;
1987 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: number): number {
1988 if(!isWasmInitialized) {
1989 throw new Error("initializeWasm() must be awaited first!");
1991 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
1992 return nativeResponseValue;
1995 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: number): number {
1996 if(!isWasmInitialized) {
1997 throw new Error("initializeWasm() must be awaited first!");
1999 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
2000 return nativeResponseValue;
2003 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: number): Level {
2004 if(!isWasmInitialized) {
2005 throw new Error("initializeWasm() must be awaited first!");
2007 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
2008 return nativeResponseValue;
2011 export class LDKMessageSendEvent {
2012 protected constructor() {}
2015 export function LDKMessageSendEvent_ty_from_ptr(ptr: number): number {
2016 if(!isWasmInitialized) {
2017 throw new Error("initializeWasm() must be awaited first!");
2019 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
2020 return nativeResponseValue;
2023 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: number): number {
2024 if(!isWasmInitialized) {
2025 throw new Error("initializeWasm() must be awaited first!");
2027 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
2028 return nativeResponseValue;
2031 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: number): number {
2032 if(!isWasmInitialized) {
2033 throw new Error("initializeWasm() must be awaited first!");
2035 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
2036 return nativeResponseValue;
2039 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: number): number {
2040 if(!isWasmInitialized) {
2041 throw new Error("initializeWasm() must be awaited first!");
2043 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
2044 return nativeResponseValue;
2047 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: number): number {
2048 if(!isWasmInitialized) {
2049 throw new Error("initializeWasm() must be awaited first!");
2051 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
2052 return nativeResponseValue;
2055 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: number): number {
2056 if(!isWasmInitialized) {
2057 throw new Error("initializeWasm() must be awaited first!");
2059 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
2060 return nativeResponseValue;
2063 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: number): number {
2064 if(!isWasmInitialized) {
2065 throw new Error("initializeWasm() must be awaited first!");
2067 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
2068 return nativeResponseValue;
2071 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: number): number {
2072 if(!isWasmInitialized) {
2073 throw new Error("initializeWasm() must be awaited first!");
2075 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
2076 return nativeResponseValue;
2079 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: number): number {
2080 if(!isWasmInitialized) {
2081 throw new Error("initializeWasm() must be awaited first!");
2083 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
2084 return nativeResponseValue;
2087 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: number): number {
2088 if(!isWasmInitialized) {
2089 throw new Error("initializeWasm() must be awaited first!");
2091 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
2092 return nativeResponseValue;
2095 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: number): number {
2096 if(!isWasmInitialized) {
2097 throw new Error("initializeWasm() must be awaited first!");
2099 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
2100 return nativeResponseValue;
2103 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: number): number {
2104 if(!isWasmInitialized) {
2105 throw new Error("initializeWasm() must be awaited first!");
2107 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
2108 return nativeResponseValue;
2111 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: number): number {
2112 if(!isWasmInitialized) {
2113 throw new Error("initializeWasm() must be awaited first!");
2115 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
2116 return nativeResponseValue;
2119 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: number): number {
2120 if(!isWasmInitialized) {
2121 throw new Error("initializeWasm() must be awaited first!");
2123 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
2124 return nativeResponseValue;
2127 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: number): number {
2128 if(!isWasmInitialized) {
2129 throw new Error("initializeWasm() must be awaited first!");
2131 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
2132 return nativeResponseValue;
2135 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: number): number {
2136 if(!isWasmInitialized) {
2137 throw new Error("initializeWasm() must be awaited first!");
2139 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
2140 return nativeResponseValue;
2143 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: number): number {
2144 if(!isWasmInitialized) {
2145 throw new Error("initializeWasm() must be awaited first!");
2147 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
2148 return nativeResponseValue;
2151 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: number): number {
2152 if(!isWasmInitialized) {
2153 throw new Error("initializeWasm() must be awaited first!");
2155 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
2156 return nativeResponseValue;
2159 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: number): number {
2160 if(!isWasmInitialized) {
2161 throw new Error("initializeWasm() must be awaited first!");
2163 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
2164 return nativeResponseValue;
2167 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: number): number {
2168 if(!isWasmInitialized) {
2169 throw new Error("initializeWasm() must be awaited first!");
2171 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
2172 return nativeResponseValue;
2175 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: number): number {
2176 if(!isWasmInitialized) {
2177 throw new Error("initializeWasm() must be awaited first!");
2179 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
2180 return nativeResponseValue;
2183 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: number): number {
2184 if(!isWasmInitialized) {
2185 throw new Error("initializeWasm() must be awaited first!");
2187 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2188 return nativeResponseValue;
2191 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: number): number {
2192 if(!isWasmInitialized) {
2193 throw new Error("initializeWasm() must be awaited first!");
2195 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2196 return nativeResponseValue;
2199 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: number): number {
2200 if(!isWasmInitialized) {
2201 throw new Error("initializeWasm() must be awaited first!");
2203 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2204 return nativeResponseValue;
2207 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: number): number {
2208 if(!isWasmInitialized) {
2209 throw new Error("initializeWasm() must be awaited first!");
2211 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2212 return nativeResponseValue;
2215 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: number): number {
2216 if(!isWasmInitialized) {
2217 throw new Error("initializeWasm() must be awaited first!");
2219 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
2220 return nativeResponseValue;
2223 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: number): number {
2224 if(!isWasmInitialized) {
2225 throw new Error("initializeWasm() must be awaited first!");
2227 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2228 return nativeResponseValue;
2231 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: number): number {
2232 if(!isWasmInitialized) {
2233 throw new Error("initializeWasm() must be awaited first!");
2235 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2236 return nativeResponseValue;
2239 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: number): number {
2240 if(!isWasmInitialized) {
2241 throw new Error("initializeWasm() must be awaited first!");
2243 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2244 return nativeResponseValue;
2247 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: number): number {
2248 if(!isWasmInitialized) {
2249 throw new Error("initializeWasm() must be awaited first!");
2251 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2252 return nativeResponseValue;
2255 export function LDKMessageSendEvent_HandleError_get_action(ptr: number): number {
2256 if(!isWasmInitialized) {
2257 throw new Error("initializeWasm() must be awaited first!");
2259 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2260 return nativeResponseValue;
2263 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: number): number {
2264 if(!isWasmInitialized) {
2265 throw new Error("initializeWasm() must be awaited first!");
2267 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2268 return nativeResponseValue;
2271 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: number): number {
2272 if(!isWasmInitialized) {
2273 throw new Error("initializeWasm() must be awaited first!");
2275 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2276 return nativeResponseValue;
2279 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: number): number {
2280 if(!isWasmInitialized) {
2281 throw new Error("initializeWasm() must be awaited first!");
2283 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2284 return nativeResponseValue;
2287 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: number): number {
2288 if(!isWasmInitialized) {
2289 throw new Error("initializeWasm() must be awaited first!");
2291 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2292 return nativeResponseValue;
2295 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: number): number {
2296 if(!isWasmInitialized) {
2297 throw new Error("initializeWasm() must be awaited first!");
2299 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2300 return nativeResponseValue;
2303 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: number): number {
2304 if(!isWasmInitialized) {
2305 throw new Error("initializeWasm() must be awaited first!");
2307 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2308 return nativeResponseValue;
2311 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: number): number {
2312 if(!isWasmInitialized) {
2313 throw new Error("initializeWasm() must be awaited first!");
2315 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
2316 return nativeResponseValue;
2319 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: number): number {
2320 if(!isWasmInitialized) {
2321 throw new Error("initializeWasm() must be awaited first!");
2323 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
2324 return nativeResponseValue;
2326 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2328 export function CResult_TxOutAccessErrorZ_get_ok(owner: number): number {
2329 if(!isWasmInitialized) {
2330 throw new Error("initializeWasm() must be awaited first!");
2332 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
2333 return nativeResponseValue;
2335 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2337 export function CResult_TxOutAccessErrorZ_get_err(owner: number): AccessError {
2338 if(!isWasmInitialized) {
2339 throw new Error("initializeWasm() must be awaited first!");
2341 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
2342 return nativeResponseValue;
2344 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2346 export function C2Tuple_usizeTransactionZ_get_a(owner: number): number {
2347 if(!isWasmInitialized) {
2348 throw new Error("initializeWasm() must be awaited first!");
2350 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2351 return nativeResponseValue;
2353 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2355 export function C2Tuple_usizeTransactionZ_get_b(owner: number): number {
2356 if(!isWasmInitialized) {
2357 throw new Error("initializeWasm() must be awaited first!");
2359 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2360 return nativeResponseValue;
2362 // void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2364 export function CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner: number): void {
2365 if(!isWasmInitialized) {
2366 throw new Error("initializeWasm() must be awaited first!");
2368 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner);
2369 // debug statements here
2371 // enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2373 export function CResult_NoneChannelMonitorUpdateErrZ_get_err(owner: number): ChannelMonitorUpdateErr {
2374 if(!isWasmInitialized) {
2375 throw new Error("initializeWasm() must be awaited first!");
2377 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(owner);
2378 return nativeResponseValue;
2381 export class LDKMonitorEvent {
2382 protected constructor() {}
2385 export function LDKMonitorEvent_ty_from_ptr(ptr: number): number {
2386 if(!isWasmInitialized) {
2387 throw new Error("initializeWasm() must be awaited first!");
2389 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2390 return nativeResponseValue;
2393 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: number): number {
2394 if(!isWasmInitialized) {
2395 throw new Error("initializeWasm() must be awaited first!");
2397 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2398 return nativeResponseValue;
2401 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: number): number {
2402 if(!isWasmInitialized) {
2403 throw new Error("initializeWasm() must be awaited first!");
2405 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
2406 return nativeResponseValue;
2409 export function LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr: number): number {
2410 if(!isWasmInitialized) {
2411 throw new Error("initializeWasm() must be awaited first!");
2413 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr);
2414 return nativeResponseValue;
2417 export function LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr: number): bigint {
2418 if(!isWasmInitialized) {
2419 throw new Error("initializeWasm() must be awaited first!");
2421 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr);
2422 return nativeResponseValue;
2425 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: number): number {
2426 if(!isWasmInitialized) {
2427 throw new Error("initializeWasm() must be awaited first!");
2429 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
2430 return nativeResponseValue;
2432 // struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2434 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner: number): number {
2435 if(!isWasmInitialized) {
2436 throw new Error("initializeWasm() must be awaited first!");
2438 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner);
2439 return nativeResponseValue;
2441 // struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2443 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner: number): number {
2444 if(!isWasmInitialized) {
2445 throw new Error("initializeWasm() must be awaited first!");
2447 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner);
2448 return nativeResponseValue;
2450 // struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner);
2452 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner: number): number {
2453 if(!isWasmInitialized) {
2454 throw new Error("initializeWasm() must be awaited first!");
2456 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner);
2457 return nativeResponseValue;
2460 export class LDKCOption_C2Tuple_usizeTransactionZZ {
2461 protected constructor() {}
2464 export function LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr: number): number {
2465 if(!isWasmInitialized) {
2466 throw new Error("initializeWasm() must be awaited first!");
2468 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr);
2469 return nativeResponseValue;
2472 export function LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr: number): number {
2473 if(!isWasmInitialized) {
2474 throw new Error("initializeWasm() must be awaited first!");
2476 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr);
2477 return nativeResponseValue;
2479 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2481 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: number): number {
2482 if(!isWasmInitialized) {
2483 throw new Error("initializeWasm() must be awaited first!");
2485 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2486 return nativeResponseValue;
2488 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2490 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: number): number {
2491 if(!isWasmInitialized) {
2492 throw new Error("initializeWasm() must be awaited first!");
2494 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2495 return nativeResponseValue;
2497 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2499 export function C2Tuple_u64u64Z_get_a(owner: number): bigint {
2500 if(!isWasmInitialized) {
2501 throw new Error("initializeWasm() must be awaited first!");
2503 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2504 return nativeResponseValue;
2506 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2508 export function C2Tuple_u64u64Z_get_b(owner: number): bigint {
2509 if(!isWasmInitialized) {
2510 throw new Error("initializeWasm() must be awaited first!");
2512 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2513 return nativeResponseValue;
2516 export class LDKCOption_C2Tuple_u64u64ZZ {
2517 protected constructor() {}
2520 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: number): number {
2521 if(!isWasmInitialized) {
2522 throw new Error("initializeWasm() must be awaited first!");
2524 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2525 return nativeResponseValue;
2528 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: number): number {
2529 if(!isWasmInitialized) {
2530 throw new Error("initializeWasm() must be awaited first!");
2532 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2533 return nativeResponseValue;
2536 export interface LDKLogger {
2537 log (record: number): void;
2541 export function LDKLogger_new(impl: LDKLogger): number {
2542 if(!isWasmInitialized) {
2543 throw new Error("initializeWasm() must be awaited first!");
2545 var new_obj_idx = js_objs.length;
2546 for (var i = 0; i < js_objs.length; i++) {
2547 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2549 js_objs[i] = new WeakRef(impl);
2550 return wasm.TS_LDKLogger_new(i);
2552 // struct LDKProbabilisticScorer *CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2554 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: number): number {
2555 if(!isWasmInitialized) {
2556 throw new Error("initializeWasm() must be awaited first!");
2558 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2559 return nativeResponseValue;
2561 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2563 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: number): number {
2564 if(!isWasmInitialized) {
2565 throw new Error("initializeWasm() must be awaited first!");
2567 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2568 return nativeResponseValue;
2570 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2572 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: number): number {
2573 if(!isWasmInitialized) {
2574 throw new Error("initializeWasm() must be awaited first!");
2576 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2577 return nativeResponseValue;
2579 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2581 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: number): number {
2582 if(!isWasmInitialized) {
2583 throw new Error("initializeWasm() must be awaited first!");
2585 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2586 return nativeResponseValue;
2588 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2590 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: number): number {
2591 if(!isWasmInitialized) {
2592 throw new Error("initializeWasm() must be awaited first!");
2594 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2595 return nativeResponseValue;
2597 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2599 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: number): number {
2600 if(!isWasmInitialized) {
2601 throw new Error("initializeWasm() must be awaited first!");
2603 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2604 return nativeResponseValue;
2606 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2608 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2609 if(!isWasmInitialized) {
2610 throw new Error("initializeWasm() must be awaited first!");
2612 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2613 return nativeResponseValue;
2615 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2617 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: number): number {
2618 if(!isWasmInitialized) {
2619 throw new Error("initializeWasm() must be awaited first!");
2621 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2622 return nativeResponseValue;
2624 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2626 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: number): number {
2627 if(!isWasmInitialized) {
2628 throw new Error("initializeWasm() must be awaited first!");
2630 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2631 return nativeResponseValue;
2633 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2635 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: number): number {
2636 if(!isWasmInitialized) {
2637 throw new Error("initializeWasm() must be awaited first!");
2639 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2640 return nativeResponseValue;
2642 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2644 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2645 if(!isWasmInitialized) {
2646 throw new Error("initializeWasm() must be awaited first!");
2648 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2649 return nativeResponseValue;
2651 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2653 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: number): number {
2654 if(!isWasmInitialized) {
2655 throw new Error("initializeWasm() must be awaited first!");
2657 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2658 return nativeResponseValue;
2660 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2662 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: number): number {
2663 if(!isWasmInitialized) {
2664 throw new Error("initializeWasm() must be awaited first!");
2666 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2667 return nativeResponseValue;
2669 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2671 export function CResult_NodeIdDecodeErrorZ_get_err(owner: number): number {
2672 if(!isWasmInitialized) {
2673 throw new Error("initializeWasm() must be awaited first!");
2675 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2676 return nativeResponseValue;
2678 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2680 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: number): number {
2681 if(!isWasmInitialized) {
2682 throw new Error("initializeWasm() must be awaited first!");
2684 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2685 return nativeResponseValue;
2687 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2689 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: number): number {
2690 if(!isWasmInitialized) {
2691 throw new Error("initializeWasm() must be awaited first!");
2693 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2694 return nativeResponseValue;
2697 export interface LDKAccess {
2698 get_utxo (genesis_hash: number, short_channel_id: bigint): number;
2702 export function LDKAccess_new(impl: LDKAccess): number {
2703 if(!isWasmInitialized) {
2704 throw new Error("initializeWasm() must be awaited first!");
2706 var new_obj_idx = js_objs.length;
2707 for (var i = 0; i < js_objs.length; i++) {
2708 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2710 js_objs[i] = new WeakRef(impl);
2711 return wasm.TS_LDKAccess_new(i);
2713 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
2715 export function Access_get_utxo(this_arg: number, genesis_hash: number, short_channel_id: bigint): number {
2716 if(!isWasmInitialized) {
2717 throw new Error("initializeWasm() must be awaited first!");
2719 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
2720 return nativeResponseValue;
2723 export class LDKCOption_AccessZ {
2724 protected constructor() {}
2727 export function LDKCOption_AccessZ_ty_from_ptr(ptr: number): number {
2728 if(!isWasmInitialized) {
2729 throw new Error("initializeWasm() must be awaited first!");
2731 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
2732 return nativeResponseValue;
2735 export function LDKCOption_AccessZ_Some_get_some(ptr: number): number {
2736 if(!isWasmInitialized) {
2737 throw new Error("initializeWasm() must be awaited first!");
2739 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
2740 return nativeResponseValue;
2742 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2744 export function CResult_boolLightningErrorZ_get_ok(owner: number): boolean {
2745 if(!isWasmInitialized) {
2746 throw new Error("initializeWasm() must be awaited first!");
2748 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
2749 return nativeResponseValue;
2751 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2753 export function CResult_boolLightningErrorZ_get_err(owner: number): number {
2754 if(!isWasmInitialized) {
2755 throw new Error("initializeWasm() must be awaited first!");
2757 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
2758 return nativeResponseValue;
2760 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2762 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: number): number {
2763 if(!isWasmInitialized) {
2764 throw new Error("initializeWasm() must be awaited first!");
2766 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
2767 return nativeResponseValue;
2769 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2771 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: number): number {
2772 if(!isWasmInitialized) {
2773 throw new Error("initializeWasm() must be awaited first!");
2775 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
2776 return nativeResponseValue;
2778 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2780 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: number): number {
2781 if(!isWasmInitialized) {
2782 throw new Error("initializeWasm() must be awaited first!");
2784 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
2785 return nativeResponseValue;
2787 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2789 export function CResult_NoneLightningErrorZ_get_ok(owner: number): void {
2790 if(!isWasmInitialized) {
2791 throw new Error("initializeWasm() must be awaited first!");
2793 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
2794 // debug statements here
2796 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2798 export function CResult_NoneLightningErrorZ_get_err(owner: number): number {
2799 if(!isWasmInitialized) {
2800 throw new Error("initializeWasm() must be awaited first!");
2802 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
2803 return nativeResponseValue;
2805 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2807 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: number): number {
2808 if(!isWasmInitialized) {
2809 throw new Error("initializeWasm() must be awaited first!");
2811 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
2812 return nativeResponseValue;
2814 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2816 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: number): number {
2817 if(!isWasmInitialized) {
2818 throw new Error("initializeWasm() must be awaited first!");
2820 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
2821 return nativeResponseValue;
2823 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2825 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: number): number {
2826 if(!isWasmInitialized) {
2827 throw new Error("initializeWasm() must be awaited first!");
2829 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
2830 return nativeResponseValue;
2832 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2834 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: number): number {
2835 if(!isWasmInitialized) {
2836 throw new Error("initializeWasm() must be awaited first!");
2838 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
2839 return nativeResponseValue;
2841 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2843 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: number): number {
2844 if(!isWasmInitialized) {
2845 throw new Error("initializeWasm() must be awaited first!");
2847 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
2848 return nativeResponseValue;
2850 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2852 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: number): number {
2853 if(!isWasmInitialized) {
2854 throw new Error("initializeWasm() must be awaited first!");
2856 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
2857 return nativeResponseValue;
2860 export class LDKNetAddress {
2861 protected constructor() {}
2864 export function LDKNetAddress_ty_from_ptr(ptr: number): number {
2865 if(!isWasmInitialized) {
2866 throw new Error("initializeWasm() must be awaited first!");
2868 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
2869 return nativeResponseValue;
2872 export function LDKNetAddress_IPv4_get_addr(ptr: number): number {
2873 if(!isWasmInitialized) {
2874 throw new Error("initializeWasm() must be awaited first!");
2876 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
2877 return nativeResponseValue;
2880 export function LDKNetAddress_IPv4_get_port(ptr: number): number {
2881 if(!isWasmInitialized) {
2882 throw new Error("initializeWasm() must be awaited first!");
2884 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
2885 return nativeResponseValue;
2888 export function LDKNetAddress_IPv6_get_addr(ptr: number): number {
2889 if(!isWasmInitialized) {
2890 throw new Error("initializeWasm() must be awaited first!");
2892 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
2893 return nativeResponseValue;
2896 export function LDKNetAddress_IPv6_get_port(ptr: number): number {
2897 if(!isWasmInitialized) {
2898 throw new Error("initializeWasm() must be awaited first!");
2900 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
2901 return nativeResponseValue;
2904 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: number): number {
2905 if(!isWasmInitialized) {
2906 throw new Error("initializeWasm() must be awaited first!");
2908 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
2909 return nativeResponseValue;
2912 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: number): number {
2913 if(!isWasmInitialized) {
2914 throw new Error("initializeWasm() must be awaited first!");
2916 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
2917 return nativeResponseValue;
2920 export function LDKNetAddress_OnionV3_get_checksum(ptr: number): number {
2921 if(!isWasmInitialized) {
2922 throw new Error("initializeWasm() must be awaited first!");
2924 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
2925 return nativeResponseValue;
2928 export function LDKNetAddress_OnionV3_get_version(ptr: number): number {
2929 if(!isWasmInitialized) {
2930 throw new Error("initializeWasm() must be awaited first!");
2932 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
2933 return nativeResponseValue;
2936 export function LDKNetAddress_OnionV3_get_port(ptr: number): number {
2937 if(!isWasmInitialized) {
2938 throw new Error("initializeWasm() must be awaited first!");
2940 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
2941 return nativeResponseValue;
2944 export function LDKNetAddress_Hostname_get_hostname(ptr: number): number {
2945 if(!isWasmInitialized) {
2946 throw new Error("initializeWasm() must be awaited first!");
2948 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_hostname(ptr);
2949 return nativeResponseValue;
2952 export function LDKNetAddress_Hostname_get_port(ptr: number): number {
2953 if(!isWasmInitialized) {
2954 throw new Error("initializeWasm() must be awaited first!");
2956 const nativeResponseValue = wasm.TS_LDKNetAddress_Hostname_get_port(ptr);
2957 return nativeResponseValue;
2959 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2961 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: number): number {
2962 if(!isWasmInitialized) {
2963 throw new Error("initializeWasm() must be awaited first!");
2965 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
2966 return nativeResponseValue;
2968 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2970 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: number): number {
2971 if(!isWasmInitialized) {
2972 throw new Error("initializeWasm() must be awaited first!");
2974 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
2975 return nativeResponseValue;
2977 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
2979 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: number): number {
2980 if(!isWasmInitialized) {
2981 throw new Error("initializeWasm() must be awaited first!");
2983 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
2984 return nativeResponseValue;
2986 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
2988 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: number): number {
2989 if(!isWasmInitialized) {
2990 throw new Error("initializeWasm() must be awaited first!");
2992 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
2993 return nativeResponseValue;
2995 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2997 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: number): number {
2998 if(!isWasmInitialized) {
2999 throw new Error("initializeWasm() must be awaited first!");
3001 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
3002 return nativeResponseValue;
3004 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
3006 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: number): number {
3007 if(!isWasmInitialized) {
3008 throw new Error("initializeWasm() must be awaited first!");
3010 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
3011 return nativeResponseValue;
3013 // struct LDKNetworkGraph *CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3015 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: number): number {
3016 if(!isWasmInitialized) {
3017 throw new Error("initializeWasm() must be awaited first!");
3019 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
3020 return nativeResponseValue;
3022 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
3024 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: number): number {
3025 if(!isWasmInitialized) {
3026 throw new Error("initializeWasm() must be awaited first!");
3028 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
3029 return nativeResponseValue;
3032 export class LDKCOption_CVec_NetAddressZZ {
3033 protected constructor() {}
3036 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: number): number {
3037 if(!isWasmInitialized) {
3038 throw new Error("initializeWasm() must be awaited first!");
3040 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
3041 return nativeResponseValue;
3044 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: number): number {
3045 if(!isWasmInitialized) {
3046 throw new Error("initializeWasm() must be awaited first!");
3048 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
3049 return nativeResponseValue;
3051 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3053 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
3054 if(!isWasmInitialized) {
3055 throw new Error("initializeWasm() must be awaited first!");
3057 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3058 return nativeResponseValue;
3060 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3062 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
3063 if(!isWasmInitialized) {
3064 throw new Error("initializeWasm() must be awaited first!");
3066 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3067 return nativeResponseValue;
3069 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3071 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
3072 if(!isWasmInitialized) {
3073 throw new Error("initializeWasm() must be awaited first!");
3075 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
3076 return nativeResponseValue;
3078 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3080 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
3081 if(!isWasmInitialized) {
3082 throw new Error("initializeWasm() must be awaited first!");
3084 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
3085 return nativeResponseValue;
3087 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3089 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
3090 if(!isWasmInitialized) {
3091 throw new Error("initializeWasm() must be awaited first!");
3093 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
3094 return nativeResponseValue;
3096 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
3098 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
3099 if(!isWasmInitialized) {
3100 throw new Error("initializeWasm() must be awaited first!");
3102 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
3103 return nativeResponseValue;
3105 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3107 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: number): number {
3108 if(!isWasmInitialized) {
3109 throw new Error("initializeWasm() must be awaited first!");
3111 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
3112 return nativeResponseValue;
3114 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
3116 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: number): number {
3117 if(!isWasmInitialized) {
3118 throw new Error("initializeWasm() must be awaited first!");
3120 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
3121 return nativeResponseValue;
3123 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3125 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: number): number {
3126 if(!isWasmInitialized) {
3127 throw new Error("initializeWasm() must be awaited first!");
3129 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
3130 return nativeResponseValue;
3132 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
3134 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: number): void {
3135 if(!isWasmInitialized) {
3136 throw new Error("initializeWasm() must be awaited first!");
3138 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
3139 // debug statements here
3141 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3143 export function CResult_SignatureNoneZ_get_ok(owner: number): number {
3144 if(!isWasmInitialized) {
3145 throw new Error("initializeWasm() must be awaited first!");
3147 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
3148 return nativeResponseValue;
3150 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
3152 export function CResult_SignatureNoneZ_get_err(owner: number): void {
3153 if(!isWasmInitialized) {
3154 throw new Error("initializeWasm() must be awaited first!");
3156 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
3157 // debug statements here
3159 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
3161 export function C2Tuple_SignatureSignatureZ_get_a(owner: number): number {
3162 if(!isWasmInitialized) {
3163 throw new Error("initializeWasm() must be awaited first!");
3165 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
3166 return nativeResponseValue;
3168 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
3170 export function C2Tuple_SignatureSignatureZ_get_b(owner: number): number {
3171 if(!isWasmInitialized) {
3172 throw new Error("initializeWasm() must be awaited first!");
3174 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
3175 return nativeResponseValue;
3177 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3179 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: number): number {
3180 if(!isWasmInitialized) {
3181 throw new Error("initializeWasm() must be awaited first!");
3183 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
3184 return nativeResponseValue;
3186 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
3188 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: number): void {
3189 if(!isWasmInitialized) {
3190 throw new Error("initializeWasm() must be awaited first!");
3192 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
3193 // debug statements here
3195 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3197 export function CResult_SecretKeyNoneZ_get_ok(owner: number): number {
3198 if(!isWasmInitialized) {
3199 throw new Error("initializeWasm() must be awaited first!");
3201 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
3202 return nativeResponseValue;
3204 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
3206 export function CResult_SecretKeyNoneZ_get_err(owner: number): void {
3207 if(!isWasmInitialized) {
3208 throw new Error("initializeWasm() must be awaited first!");
3210 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
3211 // debug statements here
3214 export interface LDKBaseSign {
3215 get_per_commitment_point (idx: bigint): number;
3216 release_commitment_secret (idx: bigint): number;
3217 validate_holder_commitment (holder_tx: number, preimages: number): number;
3218 channel_keys_id (): number;
3219 sign_counterparty_commitment (commitment_tx: number, preimages: number): number;
3220 validate_counterparty_revocation (idx: bigint, secret: number): number;
3221 sign_holder_commitment_and_htlcs (commitment_tx: number): number;
3222 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number;
3223 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number;
3224 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number;
3225 sign_closing_transaction (closing_tx: number): number;
3226 sign_channel_announcement (msg: number): number;
3227 ready_channel (channel_parameters: number): void;
3231 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: number): number {
3232 if(!isWasmInitialized) {
3233 throw new Error("initializeWasm() must be awaited first!");
3235 var new_obj_idx = js_objs.length;
3236 for (var i = 0; i < js_objs.length; i++) {
3237 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3239 js_objs[i] = new WeakRef(impl);
3240 return wasm.TS_LDKBaseSign_new(i);
3242 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3244 export function BaseSign_get_per_commitment_point(this_arg: number, idx: bigint): number {
3245 if(!isWasmInitialized) {
3246 throw new Error("initializeWasm() must be awaited first!");
3248 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
3249 return nativeResponseValue;
3251 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3253 export function BaseSign_release_commitment_secret(this_arg: number, idx: bigint): number {
3254 if(!isWasmInitialized) {
3255 throw new Error("initializeWasm() must be awaited first!");
3257 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
3258 return nativeResponseValue;
3260 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
3262 export function BaseSign_validate_holder_commitment(this_arg: number, holder_tx: number, preimages: number): number {
3263 if(!isWasmInitialized) {
3264 throw new Error("initializeWasm() must be awaited first!");
3266 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
3267 return nativeResponseValue;
3269 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
3271 export function BaseSign_channel_keys_id(this_arg: number): number {
3272 if(!isWasmInitialized) {
3273 throw new Error("initializeWasm() must be awaited first!");
3275 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
3276 return nativeResponseValue;
3278 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
3280 export function BaseSign_sign_counterparty_commitment(this_arg: number, commitment_tx: number, preimages: number): number {
3281 if(!isWasmInitialized) {
3282 throw new Error("initializeWasm() must be awaited first!");
3284 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
3285 return nativeResponseValue;
3287 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
3289 export function BaseSign_validate_counterparty_revocation(this_arg: number, idx: bigint, secret: number): number {
3290 if(!isWasmInitialized) {
3291 throw new Error("initializeWasm() must be awaited first!");
3293 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
3294 return nativeResponseValue;
3296 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
3298 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
3299 if(!isWasmInitialized) {
3300 throw new Error("initializeWasm() must be awaited first!");
3302 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
3303 return nativeResponseValue;
3305 // 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]
3307 export function BaseSign_sign_justice_revoked_output(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number {
3308 if(!isWasmInitialized) {
3309 throw new Error("initializeWasm() must be awaited first!");
3311 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
3312 return nativeResponseValue;
3314 // 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
3316 export function BaseSign_sign_justice_revoked_htlc(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number {
3317 if(!isWasmInitialized) {
3318 throw new Error("initializeWasm() must be awaited first!");
3320 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
3321 return nativeResponseValue;
3323 // 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
3325 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number {
3326 if(!isWasmInitialized) {
3327 throw new Error("initializeWasm() must be awaited first!");
3329 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
3330 return nativeResponseValue;
3332 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
3334 export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: number): number {
3335 if(!isWasmInitialized) {
3336 throw new Error("initializeWasm() must be awaited first!");
3338 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
3339 return nativeResponseValue;
3341 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
3343 export function BaseSign_sign_channel_announcement(this_arg: number, msg: number): number {
3344 if(!isWasmInitialized) {
3345 throw new Error("initializeWasm() must be awaited first!");
3347 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
3348 return nativeResponseValue;
3350 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
3352 export function BaseSign_ready_channel(this_arg: number, channel_parameters: number): void {
3353 if(!isWasmInitialized) {
3354 throw new Error("initializeWasm() must be awaited first!");
3356 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
3357 // debug statements here
3359 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
3361 export function BaseSign_get_pubkeys(this_arg: number): number {
3362 if(!isWasmInitialized) {
3363 throw new Error("initializeWasm() must be awaited first!");
3365 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
3366 return nativeResponseValue;
3369 export interface LDKSign {
3374 export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: number): number {
3375 if(!isWasmInitialized) {
3376 throw new Error("initializeWasm() must be awaited first!");
3378 var new_obj_idx = js_objs.length;
3379 for (var i = 0; i < js_objs.length; i++) {
3380 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3382 js_objs[i] = new WeakRef(impl);
3383 return wasm.TS_LDKSign_new(i);
3385 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
3387 export function Sign_write(this_arg: number): number {
3388 if(!isWasmInitialized) {
3389 throw new Error("initializeWasm() must be awaited first!");
3391 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
3392 return nativeResponseValue;
3394 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3396 export function CResult_SignDecodeErrorZ_get_ok(owner: number): number {
3397 if(!isWasmInitialized) {
3398 throw new Error("initializeWasm() must be awaited first!");
3400 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
3401 return nativeResponseValue;
3403 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3405 export function CResult_SignDecodeErrorZ_get_err(owner: number): number {
3406 if(!isWasmInitialized) {
3407 throw new Error("initializeWasm() must be awaited first!");
3409 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
3410 return nativeResponseValue;
3412 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3414 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: number): number {
3415 if(!isWasmInitialized) {
3416 throw new Error("initializeWasm() must be awaited first!");
3418 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3419 return nativeResponseValue;
3421 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3423 export function CResult_RecoverableSignatureNoneZ_get_err(owner: number): void {
3424 if(!isWasmInitialized) {
3425 throw new Error("initializeWasm() must be awaited first!");
3427 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3428 // debug statements here
3430 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3432 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: number): number {
3433 if(!isWasmInitialized) {
3434 throw new Error("initializeWasm() must be awaited first!");
3436 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
3437 return nativeResponseValue;
3439 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3441 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: number): void {
3442 if(!isWasmInitialized) {
3443 throw new Error("initializeWasm() must be awaited first!");
3445 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
3446 // debug statements here
3448 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3450 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: number): number {
3451 if(!isWasmInitialized) {
3452 throw new Error("initializeWasm() must be awaited first!");
3454 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
3455 return nativeResponseValue;
3457 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3459 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: number): number {
3460 if(!isWasmInitialized) {
3461 throw new Error("initializeWasm() must be awaited first!");
3463 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
3464 return nativeResponseValue;
3466 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3468 export function CResult_TransactionNoneZ_get_ok(owner: number): number {
3469 if(!isWasmInitialized) {
3470 throw new Error("initializeWasm() must be awaited first!");
3472 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
3473 return nativeResponseValue;
3475 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3477 export function CResult_TransactionNoneZ_get_err(owner: number): void {
3478 if(!isWasmInitialized) {
3479 throw new Error("initializeWasm() must be awaited first!");
3481 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
3482 // debug statements here
3485 export class LDKCOption_u16Z {
3486 protected constructor() {}
3489 export function LDKCOption_u16Z_ty_from_ptr(ptr: number): number {
3490 if(!isWasmInitialized) {
3491 throw new Error("initializeWasm() must be awaited first!");
3493 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
3494 return nativeResponseValue;
3497 export function LDKCOption_u16Z_Some_get_some(ptr: number): number {
3498 if(!isWasmInitialized) {
3499 throw new Error("initializeWasm() must be awaited first!");
3501 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
3502 return nativeResponseValue;
3505 export class LDKAPIError {
3506 protected constructor() {}
3509 export function LDKAPIError_ty_from_ptr(ptr: number): number {
3510 if(!isWasmInitialized) {
3511 throw new Error("initializeWasm() must be awaited first!");
3513 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
3514 return nativeResponseValue;
3517 export function LDKAPIError_APIMisuseError_get_err(ptr: number): number {
3518 if(!isWasmInitialized) {
3519 throw new Error("initializeWasm() must be awaited first!");
3521 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
3522 return nativeResponseValue;
3525 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: number): number {
3526 if(!isWasmInitialized) {
3527 throw new Error("initializeWasm() must be awaited first!");
3529 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
3530 return nativeResponseValue;
3533 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: number): number {
3534 if(!isWasmInitialized) {
3535 throw new Error("initializeWasm() must be awaited first!");
3537 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
3538 return nativeResponseValue;
3541 export function LDKAPIError_RouteError_get_err(ptr: number): number {
3542 if(!isWasmInitialized) {
3543 throw new Error("initializeWasm() must be awaited first!");
3545 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
3546 return nativeResponseValue;
3549 export function LDKAPIError_ChannelUnavailable_get_err(ptr: number): number {
3550 if(!isWasmInitialized) {
3551 throw new Error("initializeWasm() must be awaited first!");
3553 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
3554 return nativeResponseValue;
3557 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: number): number {
3558 if(!isWasmInitialized) {
3559 throw new Error("initializeWasm() must be awaited first!");
3561 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
3562 return nativeResponseValue;
3564 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3566 export function CResult_NoneAPIErrorZ_get_ok(owner: number): void {
3567 if(!isWasmInitialized) {
3568 throw new Error("initializeWasm() must be awaited first!");
3570 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
3571 // debug statements here
3573 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3575 export function CResult_NoneAPIErrorZ_get_err(owner: number): number {
3576 if(!isWasmInitialized) {
3577 throw new Error("initializeWasm() must be awaited first!");
3579 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
3580 return nativeResponseValue;
3582 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3584 export function CResult__u832APIErrorZ_get_ok(owner: number): number {
3585 if(!isWasmInitialized) {
3586 throw new Error("initializeWasm() must be awaited first!");
3588 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
3589 return nativeResponseValue;
3591 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3593 export function CResult__u832APIErrorZ_get_err(owner: number): number {
3594 if(!isWasmInitialized) {
3595 throw new Error("initializeWasm() must be awaited first!");
3597 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
3598 return nativeResponseValue;
3601 export class LDKPaymentSendFailure {
3602 protected constructor() {}
3605 export function LDKPaymentSendFailure_ty_from_ptr(ptr: number): number {
3606 if(!isWasmInitialized) {
3607 throw new Error("initializeWasm() must be awaited first!");
3609 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
3610 return nativeResponseValue;
3613 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: number): number {
3614 if(!isWasmInitialized) {
3615 throw new Error("initializeWasm() must be awaited first!");
3617 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
3618 return nativeResponseValue;
3621 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: number): number {
3622 if(!isWasmInitialized) {
3623 throw new Error("initializeWasm() must be awaited first!");
3625 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
3626 return nativeResponseValue;
3629 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: number): number {
3630 if(!isWasmInitialized) {
3631 throw new Error("initializeWasm() must be awaited first!");
3633 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
3634 return nativeResponseValue;
3637 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: number): number {
3638 if(!isWasmInitialized) {
3639 throw new Error("initializeWasm() must be awaited first!");
3641 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
3642 return nativeResponseValue;
3645 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: number): number {
3646 if(!isWasmInitialized) {
3647 throw new Error("initializeWasm() must be awaited first!");
3649 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
3650 return nativeResponseValue;
3653 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: number): number {
3654 if(!isWasmInitialized) {
3655 throw new Error("initializeWasm() must be awaited first!");
3657 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
3658 return nativeResponseValue;
3660 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3662 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: number): number {
3663 if(!isWasmInitialized) {
3664 throw new Error("initializeWasm() must be awaited first!");
3666 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
3667 return nativeResponseValue;
3669 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3671 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: number): number {
3672 if(!isWasmInitialized) {
3673 throw new Error("initializeWasm() must be awaited first!");
3675 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
3676 return nativeResponseValue;
3678 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3680 export function CResult_NonePaymentSendFailureZ_get_ok(owner: number): void {
3681 if(!isWasmInitialized) {
3682 throw new Error("initializeWasm() must be awaited first!");
3684 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
3685 // debug statements here
3687 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3689 export function CResult_NonePaymentSendFailureZ_get_err(owner: number): number {
3690 if(!isWasmInitialized) {
3691 throw new Error("initializeWasm() must be awaited first!");
3693 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
3694 return nativeResponseValue;
3696 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3698 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: number): number {
3699 if(!isWasmInitialized) {
3700 throw new Error("initializeWasm() must be awaited first!");
3702 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
3703 return nativeResponseValue;
3705 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3707 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: number): number {
3708 if(!isWasmInitialized) {
3709 throw new Error("initializeWasm() must be awaited first!");
3711 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
3712 return nativeResponseValue;
3714 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3716 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: number): number {
3717 if(!isWasmInitialized) {
3718 throw new Error("initializeWasm() must be awaited first!");
3720 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
3721 return nativeResponseValue;
3723 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3725 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: number): number {
3726 if(!isWasmInitialized) {
3727 throw new Error("initializeWasm() must be awaited first!");
3729 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
3730 return nativeResponseValue;
3732 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3734 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: number): number {
3735 if(!isWasmInitialized) {
3736 throw new Error("initializeWasm() must be awaited first!");
3738 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
3739 return nativeResponseValue;
3741 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3743 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: number): number {
3744 if(!isWasmInitialized) {
3745 throw new Error("initializeWasm() must be awaited first!");
3747 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
3748 return nativeResponseValue;
3750 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3752 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: number): number {
3753 if(!isWasmInitialized) {
3754 throw new Error("initializeWasm() must be awaited first!");
3756 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
3757 return nativeResponseValue;
3759 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3761 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: number): void {
3762 if(!isWasmInitialized) {
3763 throw new Error("initializeWasm() must be awaited first!");
3765 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
3766 // debug statements here
3768 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3770 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: number): number {
3771 if(!isWasmInitialized) {
3772 throw new Error("initializeWasm() must be awaited first!");
3774 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
3775 return nativeResponseValue;
3777 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3779 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: number): number {
3780 if(!isWasmInitialized) {
3781 throw new Error("initializeWasm() must be awaited first!");
3783 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
3784 return nativeResponseValue;
3786 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3788 export function CResult_PaymentSecretNoneZ_get_ok(owner: number): number {
3789 if(!isWasmInitialized) {
3790 throw new Error("initializeWasm() must be awaited first!");
3792 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
3793 return nativeResponseValue;
3795 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3797 export function CResult_PaymentSecretNoneZ_get_err(owner: number): void {
3798 if(!isWasmInitialized) {
3799 throw new Error("initializeWasm() must be awaited first!");
3801 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
3802 // debug statements here
3804 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3806 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: number): number {
3807 if(!isWasmInitialized) {
3808 throw new Error("initializeWasm() must be awaited first!");
3810 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
3811 return nativeResponseValue;
3813 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3815 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: number): number {
3816 if(!isWasmInitialized) {
3817 throw new Error("initializeWasm() must be awaited first!");
3819 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
3820 return nativeResponseValue;
3822 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3824 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: number): number {
3825 if(!isWasmInitialized) {
3826 throw new Error("initializeWasm() must be awaited first!");
3828 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
3829 return nativeResponseValue;
3831 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3833 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: number): number {
3834 if(!isWasmInitialized) {
3835 throw new Error("initializeWasm() must be awaited first!");
3837 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
3838 return nativeResponseValue;
3840 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3842 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: number): number {
3843 if(!isWasmInitialized) {
3844 throw new Error("initializeWasm() must be awaited first!");
3846 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
3847 return nativeResponseValue;
3849 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3851 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: number): number {
3852 if(!isWasmInitialized) {
3853 throw new Error("initializeWasm() must be awaited first!");
3855 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
3856 return nativeResponseValue;
3858 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3860 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: number): number {
3861 if(!isWasmInitialized) {
3862 throw new Error("initializeWasm() must be awaited first!");
3864 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
3865 return nativeResponseValue;
3867 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3869 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: number): number {
3870 if(!isWasmInitialized) {
3871 throw new Error("initializeWasm() must be awaited first!");
3873 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
3874 return nativeResponseValue;
3876 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3878 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: number): number {
3879 if(!isWasmInitialized) {
3880 throw new Error("initializeWasm() must be awaited first!");
3882 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
3883 return nativeResponseValue;
3885 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3887 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: number): number {
3888 if(!isWasmInitialized) {
3889 throw new Error("initializeWasm() must be awaited first!");
3891 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
3892 return nativeResponseValue;
3894 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3896 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: number): number {
3897 if(!isWasmInitialized) {
3898 throw new Error("initializeWasm() must be awaited first!");
3900 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
3901 return nativeResponseValue;
3903 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3905 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: number): number {
3906 if(!isWasmInitialized) {
3907 throw new Error("initializeWasm() must be awaited first!");
3909 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
3910 return nativeResponseValue;
3913 export interface LDKWatch {
3914 watch_channel (funding_txo: number, monitor: number): number;
3915 update_channel (funding_txo: number, update: number): number;
3916 release_pending_monitor_events (): number;
3920 export function LDKWatch_new(impl: LDKWatch): number {
3921 if(!isWasmInitialized) {
3922 throw new Error("initializeWasm() must be awaited first!");
3924 var new_obj_idx = js_objs.length;
3925 for (var i = 0; i < js_objs.length; i++) {
3926 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3928 js_objs[i] = new WeakRef(impl);
3929 return wasm.TS_LDKWatch_new(i);
3931 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
3933 export function Watch_watch_channel(this_arg: number, funding_txo: number, monitor: number): number {
3934 if(!isWasmInitialized) {
3935 throw new Error("initializeWasm() must be awaited first!");
3937 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
3938 return nativeResponseValue;
3940 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
3942 export function Watch_update_channel(this_arg: number, funding_txo: number, update: number): number {
3943 if(!isWasmInitialized) {
3944 throw new Error("initializeWasm() must be awaited first!");
3946 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
3947 return nativeResponseValue;
3949 // LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
3951 export function Watch_release_pending_monitor_events(this_arg: number): number {
3952 if(!isWasmInitialized) {
3953 throw new Error("initializeWasm() must be awaited first!");
3955 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
3956 return nativeResponseValue;
3959 export interface LDKBroadcasterInterface {
3960 broadcast_transaction (tx: number): void;
3964 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): number {
3965 if(!isWasmInitialized) {
3966 throw new Error("initializeWasm() must be awaited first!");
3968 var new_obj_idx = js_objs.length;
3969 for (var i = 0; i < js_objs.length; i++) {
3970 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3972 js_objs[i] = new WeakRef(impl);
3973 return wasm.TS_LDKBroadcasterInterface_new(i);
3975 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
3977 export function BroadcasterInterface_broadcast_transaction(this_arg: number, tx: number): void {
3978 if(!isWasmInitialized) {
3979 throw new Error("initializeWasm() must be awaited first!");
3981 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
3982 // debug statements here
3985 export interface LDKKeysInterface {
3986 get_node_secret (recipient: Recipient): number;
3987 get_destination_script (): number;
3988 get_shutdown_scriptpubkey (): number;
3989 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): number;
3990 get_secure_random_bytes (): number;
3991 read_chan_signer (reader: number): number;
3992 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): number;
3993 get_inbound_payment_key_material (): number;
3997 export function LDKKeysInterface_new(impl: LDKKeysInterface): number {
3998 if(!isWasmInitialized) {
3999 throw new Error("initializeWasm() must be awaited first!");
4001 var new_obj_idx = js_objs.length;
4002 for (var i = 0; i < js_objs.length; i++) {
4003 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4005 js_objs[i] = new WeakRef(impl);
4006 return wasm.TS_LDKKeysInterface_new(i);
4008 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
4010 export function KeysInterface_get_node_secret(this_arg: number, recipient: Recipient): number {
4011 if(!isWasmInitialized) {
4012 throw new Error("initializeWasm() must be awaited first!");
4014 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
4015 return nativeResponseValue;
4017 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
4019 export function KeysInterface_get_destination_script(this_arg: number): number {
4020 if(!isWasmInitialized) {
4021 throw new Error("initializeWasm() must be awaited first!");
4023 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
4024 return nativeResponseValue;
4026 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
4028 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: number): number {
4029 if(!isWasmInitialized) {
4030 throw new Error("initializeWasm() must be awaited first!");
4032 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
4033 return nativeResponseValue;
4035 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
4037 export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: bigint): number {
4038 if(!isWasmInitialized) {
4039 throw new Error("initializeWasm() must be awaited first!");
4041 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
4042 return nativeResponseValue;
4044 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
4046 export function KeysInterface_get_secure_random_bytes(this_arg: number): number {
4047 if(!isWasmInitialized) {
4048 throw new Error("initializeWasm() must be awaited first!");
4050 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
4051 return nativeResponseValue;
4053 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
4055 export function KeysInterface_read_chan_signer(this_arg: number, reader: number): number {
4056 if(!isWasmInitialized) {
4057 throw new Error("initializeWasm() must be awaited first!");
4059 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
4060 return nativeResponseValue;
4062 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient
4064 export function KeysInterface_sign_invoice(this_arg: number, hrp_bytes: number, invoice_data: number, receipient: Recipient): number {
4065 if(!isWasmInitialized) {
4066 throw new Error("initializeWasm() must be awaited first!");
4068 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
4069 return nativeResponseValue;
4071 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
4073 export function KeysInterface_get_inbound_payment_key_material(this_arg: number): number {
4074 if(!isWasmInitialized) {
4075 throw new Error("initializeWasm() must be awaited first!");
4077 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
4078 return nativeResponseValue;
4081 export interface LDKFeeEstimator {
4082 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
4086 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
4087 if(!isWasmInitialized) {
4088 throw new Error("initializeWasm() must be awaited first!");
4090 var new_obj_idx = js_objs.length;
4091 for (var i = 0; i < js_objs.length; i++) {
4092 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4094 js_objs[i] = new WeakRef(impl);
4095 return wasm.TS_LDKFeeEstimator_new(i);
4097 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
4099 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: ConfirmationTarget): number {
4100 if(!isWasmInitialized) {
4101 throw new Error("initializeWasm() must be awaited first!");
4103 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
4104 return nativeResponseValue;
4106 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4108 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: number): number {
4109 if(!isWasmInitialized) {
4110 throw new Error("initializeWasm() must be awaited first!");
4112 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
4113 return nativeResponseValue;
4115 // struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
4117 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: number): number {
4118 if(!isWasmInitialized) {
4119 throw new Error("initializeWasm() must be awaited first!");
4121 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
4122 return nativeResponseValue;
4124 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4126 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: number): number {
4127 if(!isWasmInitialized) {
4128 throw new Error("initializeWasm() must be awaited first!");
4130 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
4131 return nativeResponseValue;
4133 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
4135 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: number): number {
4136 if(!isWasmInitialized) {
4137 throw new Error("initializeWasm() must be awaited first!");
4139 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
4140 return nativeResponseValue;
4142 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4144 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: number): number {
4145 if(!isWasmInitialized) {
4146 throw new Error("initializeWasm() must be awaited first!");
4148 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
4149 return nativeResponseValue;
4151 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
4153 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: number): number {
4154 if(!isWasmInitialized) {
4155 throw new Error("initializeWasm() must be awaited first!");
4157 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
4158 return nativeResponseValue;
4160 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
4162 export function CResult_OutPointDecodeErrorZ_get_ok(owner: number): number {
4163 if(!isWasmInitialized) {
4164 throw new Error("initializeWasm() must be awaited first!");
4166 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
4167 return nativeResponseValue;
4169 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
4171 export function CResult_OutPointDecodeErrorZ_get_err(owner: number): number {
4172 if(!isWasmInitialized) {
4173 throw new Error("initializeWasm() must be awaited first!");
4175 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
4176 return nativeResponseValue;
4179 export interface LDKType {
4181 debug_str (): number;
4186 export function LDKType_new(impl: LDKType): number {
4187 if(!isWasmInitialized) {
4188 throw new Error("initializeWasm() must be awaited first!");
4190 var new_obj_idx = js_objs.length;
4191 for (var i = 0; i < js_objs.length; i++) {
4192 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
4194 js_objs[i] = new WeakRef(impl);
4195 return wasm.TS_LDKType_new(i);
4197 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
4199 export function Type_type_id(this_arg: number): number {
4200 if(!isWasmInitialized) {
4201 throw new Error("initializeWasm() must be awaited first!");
4203 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
4204 return nativeResponseValue;
4206 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
4208 export function Type_debug_str(this_arg: number): number {
4209 if(!isWasmInitialized) {
4210 throw new Error("initializeWasm() must be awaited first!");
4212 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
4213 return nativeResponseValue;
4215 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
4217 export function Type_write(this_arg: number): number {
4218 if(!isWasmInitialized) {
4219 throw new Error("initializeWasm() must be awaited first!");
4221 const nativeResponseValue = wasm.TS_Type_write(this_arg);
4222 return nativeResponseValue;
4225 export class LDKCOption_TypeZ {
4226 protected constructor() {}
4229 export function LDKCOption_TypeZ_ty_from_ptr(ptr: number): number {
4230 if(!isWasmInitialized) {
4231 throw new Error("initializeWasm() must be awaited first!");
4233 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
4234 return nativeResponseValue;
4237 export function LDKCOption_TypeZ_Some_get_some(ptr: number): number {
4238 if(!isWasmInitialized) {
4239 throw new Error("initializeWasm() must be awaited first!");
4241 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
4242 return nativeResponseValue;
4244 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4246 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: number): number {
4247 if(!isWasmInitialized) {
4248 throw new Error("initializeWasm() must be awaited first!");
4250 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
4251 return nativeResponseValue;
4253 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4255 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: number): number {
4256 if(!isWasmInitialized) {
4257 throw new Error("initializeWasm() must be awaited first!");
4259 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
4260 return nativeResponseValue;
4263 export class LDKPaymentError {
4264 protected constructor() {}
4267 export function LDKPaymentError_ty_from_ptr(ptr: number): number {
4268 if(!isWasmInitialized) {
4269 throw new Error("initializeWasm() must be awaited first!");
4271 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
4272 return nativeResponseValue;
4275 export function LDKPaymentError_Invoice_get_invoice(ptr: number): number {
4276 if(!isWasmInitialized) {
4277 throw new Error("initializeWasm() must be awaited first!");
4279 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
4280 return nativeResponseValue;
4283 export function LDKPaymentError_Routing_get_routing(ptr: number): number {
4284 if(!isWasmInitialized) {
4285 throw new Error("initializeWasm() must be awaited first!");
4287 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
4288 return nativeResponseValue;
4291 export function LDKPaymentError_Sending_get_sending(ptr: number): number {
4292 if(!isWasmInitialized) {
4293 throw new Error("initializeWasm() must be awaited first!");
4295 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
4296 return nativeResponseValue;
4298 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4300 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: number): number {
4301 if(!isWasmInitialized) {
4302 throw new Error("initializeWasm() must be awaited first!");
4304 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
4305 return nativeResponseValue;
4307 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4309 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: number): number {
4310 if(!isWasmInitialized) {
4311 throw new Error("initializeWasm() must be awaited first!");
4313 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
4314 return nativeResponseValue;
4317 export class LDKParseError {
4318 protected constructor() {}
4321 export function LDKParseError_ty_from_ptr(ptr: number): number {
4322 if(!isWasmInitialized) {
4323 throw new Error("initializeWasm() must be awaited first!");
4325 const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
4326 return nativeResponseValue;
4329 export function LDKParseError_Bech32Error_get_bech32_error(ptr: number): number {
4330 if(!isWasmInitialized) {
4331 throw new Error("initializeWasm() must be awaited first!");
4333 const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
4334 return nativeResponseValue;
4337 export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: number): number {
4338 if(!isWasmInitialized) {
4339 throw new Error("initializeWasm() must be awaited first!");
4341 const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
4342 return nativeResponseValue;
4345 export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: number): Secp256k1Error {
4346 if(!isWasmInitialized) {
4347 throw new Error("initializeWasm() must be awaited first!");
4349 const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
4350 return nativeResponseValue;
4353 export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: number): number {
4354 if(!isWasmInitialized) {
4355 throw new Error("initializeWasm() must be awaited first!");
4357 const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
4358 return nativeResponseValue;
4361 export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: number): number {
4362 if(!isWasmInitialized) {
4363 throw new Error("initializeWasm() must be awaited first!");
4365 const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
4366 return nativeResponseValue;
4368 // enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4370 export function CResult_SiPrefixParseErrorZ_get_ok(owner: number): SiPrefix {
4371 if(!isWasmInitialized) {
4372 throw new Error("initializeWasm() must be awaited first!");
4374 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
4375 return nativeResponseValue;
4377 // struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4379 export function CResult_SiPrefixParseErrorZ_get_err(owner: number): number {
4380 if(!isWasmInitialized) {
4381 throw new Error("initializeWasm() must be awaited first!");
4383 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
4384 return nativeResponseValue;
4387 export class LDKParseOrSemanticError {
4388 protected constructor() {}
4391 export function LDKParseOrSemanticError_ty_from_ptr(ptr: number): number {
4392 if(!isWasmInitialized) {
4393 throw new Error("initializeWasm() must be awaited first!");
4395 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
4396 return nativeResponseValue;
4399 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: number): number {
4400 if(!isWasmInitialized) {
4401 throw new Error("initializeWasm() must be awaited first!");
4403 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
4404 return nativeResponseValue;
4407 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: number): SemanticError {
4408 if(!isWasmInitialized) {
4409 throw new Error("initializeWasm() must be awaited first!");
4411 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
4412 return nativeResponseValue;
4414 // struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4416 export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: number): number {
4417 if(!isWasmInitialized) {
4418 throw new Error("initializeWasm() must be awaited first!");
4420 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
4421 return nativeResponseValue;
4423 // struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4425 export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: number): number {
4426 if(!isWasmInitialized) {
4427 throw new Error("initializeWasm() must be awaited first!");
4429 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
4430 return nativeResponseValue;
4432 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4434 export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: number): number {
4435 if(!isWasmInitialized) {
4436 throw new Error("initializeWasm() must be awaited first!");
4438 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
4439 return nativeResponseValue;
4441 // struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4443 export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: number): number {
4444 if(!isWasmInitialized) {
4445 throw new Error("initializeWasm() must be awaited first!");
4447 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
4448 return nativeResponseValue;
4450 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4452 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: number): number {
4453 if(!isWasmInitialized) {
4454 throw new Error("initializeWasm() must be awaited first!");
4456 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
4457 return nativeResponseValue;
4459 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4461 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: number): number {
4462 if(!isWasmInitialized) {
4463 throw new Error("initializeWasm() must be awaited first!");
4465 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
4466 return nativeResponseValue;
4468 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4470 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: number): number {
4471 if(!isWasmInitialized) {
4472 throw new Error("initializeWasm() must be awaited first!");
4474 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
4475 return nativeResponseValue;
4477 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4479 export function CResult_PayeePubKeyErrorZ_get_ok(owner: number): number {
4480 if(!isWasmInitialized) {
4481 throw new Error("initializeWasm() must be awaited first!");
4483 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
4484 return nativeResponseValue;
4486 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4488 export function CResult_PayeePubKeyErrorZ_get_err(owner: number): Secp256k1Error {
4489 if(!isWasmInitialized) {
4490 throw new Error("initializeWasm() must be awaited first!");
4492 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
4493 return nativeResponseValue;
4495 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4497 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: number): number {
4498 if(!isWasmInitialized) {
4499 throw new Error("initializeWasm() must be awaited first!");
4501 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
4502 return nativeResponseValue;
4504 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4506 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: number): CreationError {
4507 if(!isWasmInitialized) {
4508 throw new Error("initializeWasm() must be awaited first!");
4510 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
4511 return nativeResponseValue;
4513 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4515 export function CResult_NoneSemanticErrorZ_get_ok(owner: number): void {
4516 if(!isWasmInitialized) {
4517 throw new Error("initializeWasm() must be awaited first!");
4519 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
4520 // debug statements here
4522 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4524 export function CResult_NoneSemanticErrorZ_get_err(owner: number): SemanticError {
4525 if(!isWasmInitialized) {
4526 throw new Error("initializeWasm() must be awaited first!");
4528 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
4529 return nativeResponseValue;
4531 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4533 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: number): number {
4534 if(!isWasmInitialized) {
4535 throw new Error("initializeWasm() must be awaited first!");
4537 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
4538 return nativeResponseValue;
4540 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4542 export function CResult_InvoiceSemanticErrorZ_get_err(owner: number): SemanticError {
4543 if(!isWasmInitialized) {
4544 throw new Error("initializeWasm() must be awaited first!");
4546 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
4547 return nativeResponseValue;
4549 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4551 export function CResult_DescriptionCreationErrorZ_get_ok(owner: number): number {
4552 if(!isWasmInitialized) {
4553 throw new Error("initializeWasm() must be awaited first!");
4555 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
4556 return nativeResponseValue;
4558 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4560 export function CResult_DescriptionCreationErrorZ_get_err(owner: number): CreationError {
4561 if(!isWasmInitialized) {
4562 throw new Error("initializeWasm() must be awaited first!");
4564 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
4565 return nativeResponseValue;
4567 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4569 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: number): number {
4570 if(!isWasmInitialized) {
4571 throw new Error("initializeWasm() must be awaited first!");
4573 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
4574 return nativeResponseValue;
4576 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4578 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: number): CreationError {
4579 if(!isWasmInitialized) {
4580 throw new Error("initializeWasm() must be awaited first!");
4582 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
4583 return nativeResponseValue;
4585 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4587 export function CResult_StringErrorZ_get_ok(owner: number): number {
4588 if(!isWasmInitialized) {
4589 throw new Error("initializeWasm() must be awaited first!");
4591 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
4592 return nativeResponseValue;
4594 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4596 export function CResult_StringErrorZ_get_err(owner: number): Secp256k1Error {
4597 if(!isWasmInitialized) {
4598 throw new Error("initializeWasm() must be awaited first!");
4600 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
4601 return nativeResponseValue;
4603 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4605 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: number): number {
4606 if(!isWasmInitialized) {
4607 throw new Error("initializeWasm() must be awaited first!");
4609 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
4610 return nativeResponseValue;
4612 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4614 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: number): number {
4615 if(!isWasmInitialized) {
4616 throw new Error("initializeWasm() must be awaited first!");
4618 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
4619 return nativeResponseValue;
4622 export class LDKCOption_MonitorEventZ {
4623 protected constructor() {}
4626 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: number): number {
4627 if(!isWasmInitialized) {
4628 throw new Error("initializeWasm() must be awaited first!");
4630 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
4631 return nativeResponseValue;
4634 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: number): number {
4635 if(!isWasmInitialized) {
4636 throw new Error("initializeWasm() must be awaited first!");
4638 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
4639 return nativeResponseValue;
4641 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4643 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: number): number {
4644 if(!isWasmInitialized) {
4645 throw new Error("initializeWasm() must be awaited first!");
4647 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
4648 return nativeResponseValue;
4650 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4652 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: number): number {
4653 if(!isWasmInitialized) {
4654 throw new Error("initializeWasm() must be awaited first!");
4656 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
4657 return nativeResponseValue;
4659 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4661 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: number): number {
4662 if(!isWasmInitialized) {
4663 throw new Error("initializeWasm() must be awaited first!");
4665 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
4666 return nativeResponseValue;
4668 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4670 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: number): number {
4671 if(!isWasmInitialized) {
4672 throw new Error("initializeWasm() must be awaited first!");
4674 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
4675 return nativeResponseValue;
4677 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4679 export function C2Tuple_OutPointScriptZ_get_a(owner: number): number {
4680 if(!isWasmInitialized) {
4681 throw new Error("initializeWasm() must be awaited first!");
4683 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
4684 return nativeResponseValue;
4686 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4688 export function C2Tuple_OutPointScriptZ_get_b(owner: number): number {
4689 if(!isWasmInitialized) {
4690 throw new Error("initializeWasm() must be awaited first!");
4692 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
4693 return nativeResponseValue;
4695 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4697 export function C2Tuple_u32ScriptZ_get_a(owner: number): number {
4698 if(!isWasmInitialized) {
4699 throw new Error("initializeWasm() must be awaited first!");
4701 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
4702 return nativeResponseValue;
4704 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4706 export function C2Tuple_u32ScriptZ_get_b(owner: number): number {
4707 if(!isWasmInitialized) {
4708 throw new Error("initializeWasm() must be awaited first!");
4710 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
4711 return nativeResponseValue;
4713 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4715 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: number): number {
4716 if(!isWasmInitialized) {
4717 throw new Error("initializeWasm() must be awaited first!");
4719 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
4720 return nativeResponseValue;
4722 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4724 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: number): number {
4725 if(!isWasmInitialized) {
4726 throw new Error("initializeWasm() must be awaited first!");
4728 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
4729 return nativeResponseValue;
4731 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4733 export function C2Tuple_u32TxOutZ_get_a(owner: number): number {
4734 if(!isWasmInitialized) {
4735 throw new Error("initializeWasm() must be awaited first!");
4737 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
4738 return nativeResponseValue;
4740 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4742 export function C2Tuple_u32TxOutZ_get_b(owner: number): number {
4743 if(!isWasmInitialized) {
4744 throw new Error("initializeWasm() must be awaited first!");
4746 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
4747 return nativeResponseValue;
4749 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4751 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: number): number {
4752 if(!isWasmInitialized) {
4753 throw new Error("initializeWasm() must be awaited first!");
4755 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
4756 return nativeResponseValue;
4758 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4760 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: number): number {
4761 if(!isWasmInitialized) {
4762 throw new Error("initializeWasm() must be awaited first!");
4764 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
4765 return nativeResponseValue;
4768 export class LDKBalance {
4769 protected constructor() {}
4772 export function LDKBalance_ty_from_ptr(ptr: number): number {
4773 if(!isWasmInitialized) {
4774 throw new Error("initializeWasm() must be awaited first!");
4776 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
4777 return nativeResponseValue;
4780 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: number): bigint {
4781 if(!isWasmInitialized) {
4782 throw new Error("initializeWasm() must be awaited first!");
4784 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
4785 return nativeResponseValue;
4788 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: number): bigint {
4789 if(!isWasmInitialized) {
4790 throw new Error("initializeWasm() must be awaited first!");
4792 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
4793 return nativeResponseValue;
4796 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: number): number {
4797 if(!isWasmInitialized) {
4798 throw new Error("initializeWasm() must be awaited first!");
4800 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
4801 return nativeResponseValue;
4804 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: number): bigint {
4805 if(!isWasmInitialized) {
4806 throw new Error("initializeWasm() must be awaited first!");
4808 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
4809 return nativeResponseValue;
4812 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: number): number {
4813 if(!isWasmInitialized) {
4814 throw new Error("initializeWasm() must be awaited first!");
4816 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
4817 return nativeResponseValue;
4820 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr: number): bigint {
4821 if(!isWasmInitialized) {
4822 throw new Error("initializeWasm() must be awaited first!");
4824 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr);
4825 return nativeResponseValue;
4828 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr: number): number {
4829 if(!isWasmInitialized) {
4830 throw new Error("initializeWasm() must be awaited first!");
4832 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr);
4833 return nativeResponseValue;
4835 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4837 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: number): number {
4838 if(!isWasmInitialized) {
4839 throw new Error("initializeWasm() must be awaited first!");
4841 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
4842 return nativeResponseValue;
4844 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4846 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: number): number {
4847 if(!isWasmInitialized) {
4848 throw new Error("initializeWasm() must be awaited first!");
4850 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
4851 return nativeResponseValue;
4853 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4855 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: number): number {
4856 if(!isWasmInitialized) {
4857 throw new Error("initializeWasm() must be awaited first!");
4859 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
4860 return nativeResponseValue;
4862 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4864 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: number): number {
4865 if(!isWasmInitialized) {
4866 throw new Error("initializeWasm() must be awaited first!");
4868 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
4869 return nativeResponseValue;
4871 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4873 export function C2Tuple_PublicKeyTypeZ_get_a(owner: number): number {
4874 if(!isWasmInitialized) {
4875 throw new Error("initializeWasm() must be awaited first!");
4877 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
4878 return nativeResponseValue;
4880 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4882 export function C2Tuple_PublicKeyTypeZ_get_b(owner: number): number {
4883 if(!isWasmInitialized) {
4884 throw new Error("initializeWasm() must be awaited first!");
4886 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
4887 return nativeResponseValue;
4890 export class LDKCOption_NetAddressZ {
4891 protected constructor() {}
4894 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: number): number {
4895 if(!isWasmInitialized) {
4896 throw new Error("initializeWasm() must be awaited first!");
4898 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
4899 return nativeResponseValue;
4902 export function LDKCOption_NetAddressZ_Some_get_some(ptr: number): number {
4903 if(!isWasmInitialized) {
4904 throw new Error("initializeWasm() must be awaited first!");
4906 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
4907 return nativeResponseValue;
4909 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4911 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: number): number {
4912 if(!isWasmInitialized) {
4913 throw new Error("initializeWasm() must be awaited first!");
4915 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
4916 return nativeResponseValue;
4918 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4920 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: number): number {
4921 if(!isWasmInitialized) {
4922 throw new Error("initializeWasm() must be awaited first!");
4924 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
4925 return nativeResponseValue;
4927 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4929 export function CResult_NonePeerHandleErrorZ_get_ok(owner: number): void {
4930 if(!isWasmInitialized) {
4931 throw new Error("initializeWasm() must be awaited first!");
4933 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
4934 // debug statements here
4936 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4938 export function CResult_NonePeerHandleErrorZ_get_err(owner: number): number {
4939 if(!isWasmInitialized) {
4940 throw new Error("initializeWasm() must be awaited first!");
4942 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
4943 return nativeResponseValue;
4945 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4947 export function CResult_boolPeerHandleErrorZ_get_ok(owner: number): boolean {
4948 if(!isWasmInitialized) {
4949 throw new Error("initializeWasm() must be awaited first!");
4951 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
4952 return nativeResponseValue;
4954 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4956 export function CResult_boolPeerHandleErrorZ_get_err(owner: number): number {
4957 if(!isWasmInitialized) {
4958 throw new Error("initializeWasm() must be awaited first!");
4960 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
4961 return nativeResponseValue;
4963 // void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4965 export function CResult_NoneErrorZ_get_ok(owner: number): void {
4966 if(!isWasmInitialized) {
4967 throw new Error("initializeWasm() must be awaited first!");
4969 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_ok(owner);
4970 // debug statements here
4972 // enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4974 export function CResult_NoneErrorZ_get_err(owner: number): IOError {
4975 if(!isWasmInitialized) {
4976 throw new Error("initializeWasm() must be awaited first!");
4978 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_err(owner);
4979 return nativeResponseValue;
4981 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4983 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: number): number {
4984 if(!isWasmInitialized) {
4985 throw new Error("initializeWasm() must be awaited first!");
4987 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
4988 return nativeResponseValue;
4990 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4992 export function CResult_NetAddressDecodeErrorZ_get_err(owner: number): number {
4993 if(!isWasmInitialized) {
4994 throw new Error("initializeWasm() must be awaited first!");
4996 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
4997 return nativeResponseValue;
4999 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5001 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: number): number {
5002 if(!isWasmInitialized) {
5003 throw new Error("initializeWasm() must be awaited first!");
5005 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
5006 return nativeResponseValue;
5008 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
5010 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: number): number {
5011 if(!isWasmInitialized) {
5012 throw new Error("initializeWasm() must be awaited first!");
5014 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
5015 return nativeResponseValue;
5017 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5019 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: number): number {
5020 if(!isWasmInitialized) {
5021 throw new Error("initializeWasm() must be awaited first!");
5023 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
5024 return nativeResponseValue;
5026 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
5028 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: number): number {
5029 if(!isWasmInitialized) {
5030 throw new Error("initializeWasm() must be awaited first!");
5032 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
5033 return nativeResponseValue;
5035 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
5037 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: number): number {
5038 if(!isWasmInitialized) {
5039 throw new Error("initializeWasm() must be awaited first!");
5041 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
5042 return nativeResponseValue;
5044 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
5046 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: number): number {
5047 if(!isWasmInitialized) {
5048 throw new Error("initializeWasm() must be awaited first!");
5050 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
5051 return nativeResponseValue;
5053 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
5055 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: number): number {
5056 if(!isWasmInitialized) {
5057 throw new Error("initializeWasm() must be awaited first!");
5059 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
5060 return nativeResponseValue;
5062 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
5064 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: number): number {
5065 if(!isWasmInitialized) {
5066 throw new Error("initializeWasm() must be awaited first!");
5068 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
5069 return nativeResponseValue;
5071 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
5073 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: number): number {
5074 if(!isWasmInitialized) {
5075 throw new Error("initializeWasm() must be awaited first!");
5077 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
5078 return nativeResponseValue;
5080 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
5082 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: number): number {
5083 if(!isWasmInitialized) {
5084 throw new Error("initializeWasm() must be awaited first!");
5086 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
5087 return nativeResponseValue;
5089 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
5091 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: number): number {
5092 if(!isWasmInitialized) {
5093 throw new Error("initializeWasm() must be awaited first!");
5095 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
5096 return nativeResponseValue;
5098 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
5100 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: number): number {
5101 if(!isWasmInitialized) {
5102 throw new Error("initializeWasm() must be awaited first!");
5104 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
5105 return nativeResponseValue;
5107 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
5109 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: number): number {
5110 if(!isWasmInitialized) {
5111 throw new Error("initializeWasm() must be awaited first!");
5113 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
5114 return nativeResponseValue;
5116 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
5118 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: number): number {
5119 if(!isWasmInitialized) {
5120 throw new Error("initializeWasm() must be awaited first!");
5122 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
5123 return nativeResponseValue;
5125 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
5127 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: number): number {
5128 if(!isWasmInitialized) {
5129 throw new Error("initializeWasm() must be awaited first!");
5131 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
5132 return nativeResponseValue;
5134 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
5136 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: number): number {
5137 if(!isWasmInitialized) {
5138 throw new Error("initializeWasm() must be awaited first!");
5140 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
5141 return nativeResponseValue;
5143 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
5145 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: number): number {
5146 if(!isWasmInitialized) {
5147 throw new Error("initializeWasm() must be awaited first!");
5149 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
5150 return nativeResponseValue;
5152 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
5154 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: number): number {
5155 if(!isWasmInitialized) {
5156 throw new Error("initializeWasm() must be awaited first!");
5158 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
5159 return nativeResponseValue;
5161 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
5163 export function CResult_InitDecodeErrorZ_get_ok(owner: number): number {
5164 if(!isWasmInitialized) {
5165 throw new Error("initializeWasm() must be awaited first!");
5167 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
5168 return nativeResponseValue;
5170 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
5172 export function CResult_InitDecodeErrorZ_get_err(owner: number): number {
5173 if(!isWasmInitialized) {
5174 throw new Error("initializeWasm() must be awaited first!");
5176 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
5177 return nativeResponseValue;
5179 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5181 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: number): number {
5182 if(!isWasmInitialized) {
5183 throw new Error("initializeWasm() must be awaited first!");
5185 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
5186 return nativeResponseValue;
5188 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
5190 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: number): number {
5191 if(!isWasmInitialized) {
5192 throw new Error("initializeWasm() must be awaited first!");
5194 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
5195 return nativeResponseValue;
5197 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5199 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: number): number {
5200 if(!isWasmInitialized) {
5201 throw new Error("initializeWasm() must be awaited first!");
5203 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
5204 return nativeResponseValue;
5206 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5208 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: number): number {
5209 if(!isWasmInitialized) {
5210 throw new Error("initializeWasm() must be awaited first!");
5212 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
5213 return nativeResponseValue;
5215 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5217 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: number): number {
5218 if(!isWasmInitialized) {
5219 throw new Error("initializeWasm() must be awaited first!");
5221 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
5222 return nativeResponseValue;
5224 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5226 export function CResult_ShutdownDecodeErrorZ_get_err(owner: number): number {
5227 if(!isWasmInitialized) {
5228 throw new Error("initializeWasm() must be awaited first!");
5230 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
5231 return nativeResponseValue;
5233 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5235 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: number): number {
5236 if(!isWasmInitialized) {
5237 throw new Error("initializeWasm() must be awaited first!");
5239 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
5240 return nativeResponseValue;
5242 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5244 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: number): number {
5245 if(!isWasmInitialized) {
5246 throw new Error("initializeWasm() must be awaited first!");
5248 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
5249 return nativeResponseValue;
5251 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5253 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: number): number {
5254 if(!isWasmInitialized) {
5255 throw new Error("initializeWasm() must be awaited first!");
5257 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
5258 return nativeResponseValue;
5260 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5262 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: number): number {
5263 if(!isWasmInitialized) {
5264 throw new Error("initializeWasm() must be awaited first!");
5266 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
5267 return nativeResponseValue;
5269 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5271 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: number): number {
5272 if(!isWasmInitialized) {
5273 throw new Error("initializeWasm() must be awaited first!");
5275 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
5276 return nativeResponseValue;
5278 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5280 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: number): number {
5281 if(!isWasmInitialized) {
5282 throw new Error("initializeWasm() must be awaited first!");
5284 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
5285 return nativeResponseValue;
5287 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5289 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: number): number {
5290 if(!isWasmInitialized) {
5291 throw new Error("initializeWasm() must be awaited first!");
5293 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
5294 return nativeResponseValue;
5296 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5298 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: number): number {
5299 if(!isWasmInitialized) {
5300 throw new Error("initializeWasm() must be awaited first!");
5302 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
5303 return nativeResponseValue;
5305 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5307 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: number): number {
5308 if(!isWasmInitialized) {
5309 throw new Error("initializeWasm() must be awaited first!");
5311 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
5312 return nativeResponseValue;
5314 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5316 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: number): number {
5317 if(!isWasmInitialized) {
5318 throw new Error("initializeWasm() must be awaited first!");
5320 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
5321 return nativeResponseValue;
5323 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5325 export function CResult_PingDecodeErrorZ_get_ok(owner: number): number {
5326 if(!isWasmInitialized) {
5327 throw new Error("initializeWasm() must be awaited first!");
5329 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
5330 return nativeResponseValue;
5332 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5334 export function CResult_PingDecodeErrorZ_get_err(owner: number): number {
5335 if(!isWasmInitialized) {
5336 throw new Error("initializeWasm() must be awaited first!");
5338 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
5339 return nativeResponseValue;
5341 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5343 export function CResult_PongDecodeErrorZ_get_ok(owner: number): number {
5344 if(!isWasmInitialized) {
5345 throw new Error("initializeWasm() must be awaited first!");
5347 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
5348 return nativeResponseValue;
5350 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5352 export function CResult_PongDecodeErrorZ_get_err(owner: number): number {
5353 if(!isWasmInitialized) {
5354 throw new Error("initializeWasm() must be awaited first!");
5356 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
5357 return nativeResponseValue;
5359 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5361 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5362 if(!isWasmInitialized) {
5363 throw new Error("initializeWasm() must be awaited first!");
5365 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
5366 return nativeResponseValue;
5368 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5370 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5371 if(!isWasmInitialized) {
5372 throw new Error("initializeWasm() must be awaited first!");
5374 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
5375 return nativeResponseValue;
5377 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5379 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5380 if(!isWasmInitialized) {
5381 throw new Error("initializeWasm() must be awaited first!");
5383 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
5384 return nativeResponseValue;
5386 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5388 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5389 if(!isWasmInitialized) {
5390 throw new Error("initializeWasm() must be awaited first!");
5392 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
5393 return nativeResponseValue;
5395 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5397 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5398 if(!isWasmInitialized) {
5399 throw new Error("initializeWasm() must be awaited first!");
5401 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
5402 return nativeResponseValue;
5404 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5406 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5407 if(!isWasmInitialized) {
5408 throw new Error("initializeWasm() must be awaited first!");
5410 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
5411 return nativeResponseValue;
5413 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5415 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5416 if(!isWasmInitialized) {
5417 throw new Error("initializeWasm() must be awaited first!");
5419 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
5420 return nativeResponseValue;
5422 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5424 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5425 if(!isWasmInitialized) {
5426 throw new Error("initializeWasm() must be awaited first!");
5428 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
5429 return nativeResponseValue;
5431 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5433 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: number): number {
5434 if(!isWasmInitialized) {
5435 throw new Error("initializeWasm() must be awaited first!");
5437 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
5438 return nativeResponseValue;
5440 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5442 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: number): number {
5443 if(!isWasmInitialized) {
5444 throw new Error("initializeWasm() must be awaited first!");
5446 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
5447 return nativeResponseValue;
5449 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5451 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: number): number {
5452 if(!isWasmInitialized) {
5453 throw new Error("initializeWasm() must be awaited first!");
5455 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
5456 return nativeResponseValue;
5458 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5460 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: number): number {
5461 if(!isWasmInitialized) {
5462 throw new Error("initializeWasm() must be awaited first!");
5464 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
5465 return nativeResponseValue;
5467 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5469 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5470 if(!isWasmInitialized) {
5471 throw new Error("initializeWasm() must be awaited first!");
5473 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
5474 return nativeResponseValue;
5476 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5478 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5479 if(!isWasmInitialized) {
5480 throw new Error("initializeWasm() must be awaited first!");
5482 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
5483 return nativeResponseValue;
5485 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5487 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5488 if(!isWasmInitialized) {
5489 throw new Error("initializeWasm() must be awaited first!");
5491 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
5492 return nativeResponseValue;
5494 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5496 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5497 if(!isWasmInitialized) {
5498 throw new Error("initializeWasm() must be awaited first!");
5500 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
5501 return nativeResponseValue;
5503 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5505 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: number): number {
5506 if(!isWasmInitialized) {
5507 throw new Error("initializeWasm() must be awaited first!");
5509 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
5510 return nativeResponseValue;
5512 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5514 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: number): number {
5515 if(!isWasmInitialized) {
5516 throw new Error("initializeWasm() must be awaited first!");
5518 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
5519 return nativeResponseValue;
5521 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5523 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: number): number {
5524 if(!isWasmInitialized) {
5525 throw new Error("initializeWasm() must be awaited first!");
5527 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
5528 return nativeResponseValue;
5530 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5532 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: number): number {
5533 if(!isWasmInitialized) {
5534 throw new Error("initializeWasm() must be awaited first!");
5536 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
5537 return nativeResponseValue;
5539 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5541 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5542 if(!isWasmInitialized) {
5543 throw new Error("initializeWasm() must be awaited first!");
5545 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
5546 return nativeResponseValue;
5548 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5550 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: number): number {
5551 if(!isWasmInitialized) {
5552 throw new Error("initializeWasm() must be awaited first!");
5554 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
5555 return nativeResponseValue;
5557 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5559 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5560 if(!isWasmInitialized) {
5561 throw new Error("initializeWasm() must be awaited first!");
5563 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
5564 return nativeResponseValue;
5566 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5568 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: number): number {
5569 if(!isWasmInitialized) {
5570 throw new Error("initializeWasm() must be awaited first!");
5572 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
5573 return nativeResponseValue;
5575 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5577 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: number): number {
5578 if(!isWasmInitialized) {
5579 throw new Error("initializeWasm() must be awaited first!");
5581 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
5582 return nativeResponseValue;
5584 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5586 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: number): number {
5587 if(!isWasmInitialized) {
5588 throw new Error("initializeWasm() must be awaited first!");
5590 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
5591 return nativeResponseValue;
5594 export class LDKSignOrCreationError {
5595 protected constructor() {}
5598 export function LDKSignOrCreationError_ty_from_ptr(ptr: number): number {
5599 if(!isWasmInitialized) {
5600 throw new Error("initializeWasm() must be awaited first!");
5602 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
5603 return nativeResponseValue;
5606 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: number): CreationError {
5607 if(!isWasmInitialized) {
5608 throw new Error("initializeWasm() must be awaited first!");
5610 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
5611 return nativeResponseValue;
5613 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5615 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: number): number {
5616 if(!isWasmInitialized) {
5617 throw new Error("initializeWasm() must be awaited first!");
5619 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
5620 return nativeResponseValue;
5622 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5624 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: number): number {
5625 if(!isWasmInitialized) {
5626 throw new Error("initializeWasm() must be awaited first!");
5628 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
5629 return nativeResponseValue;
5632 export interface LDKFilter {
5633 register_tx (txid: number, script_pubkey: number): void;
5634 register_output (output: number): number;
5638 export function LDKFilter_new(impl: LDKFilter): number {
5639 if(!isWasmInitialized) {
5640 throw new Error("initializeWasm() must be awaited first!");
5642 var new_obj_idx = js_objs.length;
5643 for (var i = 0; i < js_objs.length; i++) {
5644 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5646 js_objs[i] = new WeakRef(impl);
5647 return wasm.TS_LDKFilter_new(i);
5649 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
5651 export function Filter_register_tx(this_arg: number, txid: number, script_pubkey: number): void {
5652 if(!isWasmInitialized) {
5653 throw new Error("initializeWasm() must be awaited first!");
5655 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
5656 // debug statements here
5658 // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
5660 export function Filter_register_output(this_arg: number, output: number): number {
5661 if(!isWasmInitialized) {
5662 throw new Error("initializeWasm() must be awaited first!");
5664 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
5665 return nativeResponseValue;
5668 export class LDKCOption_FilterZ {
5669 protected constructor() {}
5672 export function LDKCOption_FilterZ_ty_from_ptr(ptr: number): number {
5673 if(!isWasmInitialized) {
5674 throw new Error("initializeWasm() must be awaited first!");
5676 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
5677 return nativeResponseValue;
5680 export function LDKCOption_FilterZ_Some_get_some(ptr: number): number {
5681 if(!isWasmInitialized) {
5682 throw new Error("initializeWasm() must be awaited first!");
5684 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
5685 return nativeResponseValue;
5687 // struct LDKLockedChannelMonitor *CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5689 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: number): number {
5690 if(!isWasmInitialized) {
5691 throw new Error("initializeWasm() must be awaited first!");
5693 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
5694 return nativeResponseValue;
5696 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5698 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: number): void {
5699 if(!isWasmInitialized) {
5700 throw new Error("initializeWasm() must be awaited first!");
5702 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
5703 // debug statements here
5706 export interface LDKMessageSendEventsProvider {
5707 get_and_clear_pending_msg_events (): number;
5711 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): number {
5712 if(!isWasmInitialized) {
5713 throw new Error("initializeWasm() must be awaited first!");
5715 var new_obj_idx = js_objs.length;
5716 for (var i = 0; i < js_objs.length; i++) {
5717 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5719 js_objs[i] = new WeakRef(impl);
5720 return wasm.TS_LDKMessageSendEventsProvider_new(i);
5722 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
5724 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: number): number {
5725 if(!isWasmInitialized) {
5726 throw new Error("initializeWasm() must be awaited first!");
5728 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
5729 return nativeResponseValue;
5732 export interface LDKEventHandler {
5733 handle_event (event: number): void;
5737 export function LDKEventHandler_new(impl: LDKEventHandler): number {
5738 if(!isWasmInitialized) {
5739 throw new Error("initializeWasm() must be awaited first!");
5741 var new_obj_idx = js_objs.length;
5742 for (var i = 0; i < js_objs.length; i++) {
5743 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5745 js_objs[i] = new WeakRef(impl);
5746 return wasm.TS_LDKEventHandler_new(i);
5748 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
5750 export function EventHandler_handle_event(this_arg: number, event: number): void {
5751 if(!isWasmInitialized) {
5752 throw new Error("initializeWasm() must be awaited first!");
5754 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
5755 // debug statements here
5758 export interface LDKEventsProvider {
5759 process_pending_events (handler: number): void;
5763 export function LDKEventsProvider_new(impl: LDKEventsProvider): number {
5764 if(!isWasmInitialized) {
5765 throw new Error("initializeWasm() must be awaited first!");
5767 var new_obj_idx = js_objs.length;
5768 for (var i = 0; i < js_objs.length; i++) {
5769 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5771 js_objs[i] = new WeakRef(impl);
5772 return wasm.TS_LDKEventsProvider_new(i);
5774 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
5776 export function EventsProvider_process_pending_events(this_arg: number, handler: number): void {
5777 if(!isWasmInitialized) {
5778 throw new Error("initializeWasm() must be awaited first!");
5780 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
5781 // debug statements here
5784 export interface LDKScore {
5785 channel_penalty_msat (short_channel_id: bigint, source: number, target: number, usage: number): bigint;
5786 payment_path_failed (path: number, short_channel_id: bigint): void;
5787 payment_path_successful (path: number): void;
5788 probe_failed (path: number, short_channel_id: bigint): void;
5789 probe_successful (path: number): void;
5794 export function LDKScore_new(impl: LDKScore): number {
5795 if(!isWasmInitialized) {
5796 throw new Error("initializeWasm() must be awaited first!");
5798 var new_obj_idx = js_objs.length;
5799 for (var i = 0; i < js_objs.length; i++) {
5800 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5802 js_objs[i] = new WeakRef(impl);
5803 return wasm.TS_LDKScore_new(i);
5805 // 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
5807 export function Score_channel_penalty_msat(this_arg: number, short_channel_id: bigint, source: number, target: number, usage: number): bigint {
5808 if(!isWasmInitialized) {
5809 throw new Error("initializeWasm() must be awaited first!");
5811 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage);
5812 return nativeResponseValue;
5814 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5816 export function Score_payment_path_failed(this_arg: number, path: number, short_channel_id: bigint): void {
5817 if(!isWasmInitialized) {
5818 throw new Error("initializeWasm() must be awaited first!");
5820 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
5821 // debug statements here
5823 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5825 export function Score_payment_path_successful(this_arg: number, path: number): void {
5826 if(!isWasmInitialized) {
5827 throw new Error("initializeWasm() must be awaited first!");
5829 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
5830 // debug statements here
5832 // void Score_probe_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5834 export function Score_probe_failed(this_arg: number, path: number, short_channel_id: bigint): void {
5835 if(!isWasmInitialized) {
5836 throw new Error("initializeWasm() must be awaited first!");
5838 const nativeResponseValue = wasm.TS_Score_probe_failed(this_arg, path, short_channel_id);
5839 // debug statements here
5841 // void Score_probe_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5843 export function Score_probe_successful(this_arg: number, path: number): void {
5844 if(!isWasmInitialized) {
5845 throw new Error("initializeWasm() must be awaited first!");
5847 const nativeResponseValue = wasm.TS_Score_probe_successful(this_arg, path);
5848 // debug statements here
5850 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
5852 export function Score_write(this_arg: number): number {
5853 if(!isWasmInitialized) {
5854 throw new Error("initializeWasm() must be awaited first!");
5856 const nativeResponseValue = wasm.TS_Score_write(this_arg);
5857 return nativeResponseValue;
5860 export interface LDKPersister {
5861 persist_manager (channel_manager: number): number;
5862 persist_graph (network_graph: number): number;
5863 persist_scorer (scorer: number): number;
5867 export function LDKPersister_new(impl: LDKPersister): number {
5868 if(!isWasmInitialized) {
5869 throw new Error("initializeWasm() must be awaited first!");
5871 var new_obj_idx = js_objs.length;
5872 for (var i = 0; i < js_objs.length; i++) {
5873 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5875 js_objs[i] = new WeakRef(impl);
5876 return wasm.TS_LDKPersister_new(i);
5878 // LDKCResult_NoneErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
5880 export function Persister_persist_manager(this_arg: number, channel_manager: number): number {
5881 if(!isWasmInitialized) {
5882 throw new Error("initializeWasm() must be awaited first!");
5884 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
5885 return nativeResponseValue;
5887 // LDKCResult_NoneErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
5889 export function Persister_persist_graph(this_arg: number, network_graph: number): number {
5890 if(!isWasmInitialized) {
5891 throw new Error("initializeWasm() must be awaited first!");
5893 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
5894 return nativeResponseValue;
5896 // LDKCResult_NoneErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKMultiThreadedLockableScore *NONNULL_PTR scorer
5898 export function Persister_persist_scorer(this_arg: number, scorer: number): number {
5899 if(!isWasmInitialized) {
5900 throw new Error("initializeWasm() must be awaited first!");
5902 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
5903 return nativeResponseValue;
5906 export interface LDKListen {
5907 filtered_block_connected (header: number, txdata: number, height: number): void;
5908 block_connected (block: number, height: number): void;
5909 block_disconnected (header: number, height: number): void;
5913 export function LDKListen_new(impl: LDKListen): number {
5914 if(!isWasmInitialized) {
5915 throw new Error("initializeWasm() must be awaited first!");
5917 var new_obj_idx = js_objs.length;
5918 for (var i = 0; i < js_objs.length; i++) {
5919 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5921 js_objs[i] = new WeakRef(impl);
5922 return wasm.TS_LDKListen_new(i);
5924 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5926 export function Listen_filtered_block_connected(this_arg: number, header: number, txdata: number, height: number): void {
5927 if(!isWasmInitialized) {
5928 throw new Error("initializeWasm() must be awaited first!");
5930 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
5931 // debug statements here
5933 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
5935 export function Listen_block_connected(this_arg: number, block: number, height: number): void {
5936 if(!isWasmInitialized) {
5937 throw new Error("initializeWasm() must be awaited first!");
5939 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
5940 // debug statements here
5942 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5944 export function Listen_block_disconnected(this_arg: number, header: number, height: number): void {
5945 if(!isWasmInitialized) {
5946 throw new Error("initializeWasm() must be awaited first!");
5948 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
5949 // debug statements here
5952 export interface LDKConfirm {
5953 transactions_confirmed (header: number, txdata: number, height: number): void;
5954 transaction_unconfirmed (txid: number): void;
5955 best_block_updated (header: number, height: number): void;
5956 get_relevant_txids (): number;
5960 export function LDKConfirm_new(impl: LDKConfirm): number {
5961 if(!isWasmInitialized) {
5962 throw new Error("initializeWasm() must be awaited first!");
5964 var new_obj_idx = js_objs.length;
5965 for (var i = 0; i < js_objs.length; i++) {
5966 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5968 js_objs[i] = new WeakRef(impl);
5969 return wasm.TS_LDKConfirm_new(i);
5971 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5973 export function Confirm_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number): void {
5974 if(!isWasmInitialized) {
5975 throw new Error("initializeWasm() must be awaited first!");
5977 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
5978 // debug statements here
5980 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
5982 export function Confirm_transaction_unconfirmed(this_arg: number, txid: number): void {
5983 if(!isWasmInitialized) {
5984 throw new Error("initializeWasm() must be awaited first!");
5986 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
5987 // debug statements here
5989 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5991 export function Confirm_best_block_updated(this_arg: number, header: number, height: number): void {
5992 if(!isWasmInitialized) {
5993 throw new Error("initializeWasm() must be awaited first!");
5995 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
5996 // debug statements here
5998 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
6000 export function Confirm_get_relevant_txids(this_arg: number): number {
6001 if(!isWasmInitialized) {
6002 throw new Error("initializeWasm() must be awaited first!");
6004 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
6005 return nativeResponseValue;
6008 export interface LDKPersist {
6009 persist_new_channel (channel_id: number, data: number, update_id: number): number;
6010 update_persisted_channel (channel_id: number, update: number, data: number, update_id: number): number;
6014 export function LDKPersist_new(impl: LDKPersist): number {
6015 if(!isWasmInitialized) {
6016 throw new Error("initializeWasm() must be awaited first!");
6018 var new_obj_idx = js_objs.length;
6019 for (var i = 0; i < js_objs.length; i++) {
6020 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6022 js_objs[i] = new WeakRef(impl);
6023 return wasm.TS_LDKPersist_new(i);
6025 // 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
6027 export function Persist_persist_new_channel(this_arg: number, channel_id: number, data: number, update_id: number): number {
6028 if(!isWasmInitialized) {
6029 throw new Error("initializeWasm() must be awaited first!");
6031 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
6032 return nativeResponseValue;
6034 // 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
6036 export function Persist_update_persisted_channel(this_arg: number, channel_id: number, update: number, data: number, update_id: number): number {
6037 if(!isWasmInitialized) {
6038 throw new Error("initializeWasm() must be awaited first!");
6040 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
6041 return nativeResponseValue;
6044 export interface LDKChannelMessageHandler {
6045 handle_open_channel (their_node_id: number, their_features: number, msg: number): void;
6046 handle_accept_channel (their_node_id: number, their_features: number, msg: number): void;
6047 handle_funding_created (their_node_id: number, msg: number): void;
6048 handle_funding_signed (their_node_id: number, msg: number): void;
6049 handle_channel_ready (their_node_id: number, msg: number): void;
6050 handle_shutdown (their_node_id: number, their_features: number, msg: number): void;
6051 handle_closing_signed (their_node_id: number, msg: number): void;
6052 handle_update_add_htlc (their_node_id: number, msg: number): void;
6053 handle_update_fulfill_htlc (their_node_id: number, msg: number): void;
6054 handle_update_fail_htlc (their_node_id: number, msg: number): void;
6055 handle_update_fail_malformed_htlc (their_node_id: number, msg: number): void;
6056 handle_commitment_signed (their_node_id: number, msg: number): void;
6057 handle_revoke_and_ack (their_node_id: number, msg: number): void;
6058 handle_update_fee (their_node_id: number, msg: number): void;
6059 handle_announcement_signatures (their_node_id: number, msg: number): void;
6060 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
6061 peer_connected (their_node_id: number, msg: number): void;
6062 handle_channel_reestablish (their_node_id: number, msg: number): void;
6063 handle_channel_update (their_node_id: number, msg: number): void;
6064 handle_error (their_node_id: number, msg: number): void;
6068 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
6069 if(!isWasmInitialized) {
6070 throw new Error("initializeWasm() must be awaited first!");
6072 var new_obj_idx = js_objs.length;
6073 for (var i = 0; i < js_objs.length; i++) {
6074 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6076 js_objs[i] = new WeakRef(impl);
6077 return wasm.TS_LDKChannelMessageHandler_new(i);
6079 // 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
6081 export function ChannelMessageHandler_handle_open_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
6082 if(!isWasmInitialized) {
6083 throw new Error("initializeWasm() must be awaited first!");
6085 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
6086 // debug statements here
6088 // 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
6090 export function ChannelMessageHandler_handle_accept_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
6091 if(!isWasmInitialized) {
6092 throw new Error("initializeWasm() must be awaited first!");
6094 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
6095 // debug statements here
6097 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
6099 export function ChannelMessageHandler_handle_funding_created(this_arg: number, their_node_id: number, msg: number): void {
6100 if(!isWasmInitialized) {
6101 throw new Error("initializeWasm() must be awaited first!");
6103 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
6104 // debug statements here
6106 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
6108 export function ChannelMessageHandler_handle_funding_signed(this_arg: number, their_node_id: number, msg: number): void {
6109 if(!isWasmInitialized) {
6110 throw new Error("initializeWasm() must be awaited first!");
6112 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
6113 // debug statements here
6115 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
6117 export function ChannelMessageHandler_handle_channel_ready(this_arg: number, their_node_id: number, msg: number): void {
6118 if(!isWasmInitialized) {
6119 throw new Error("initializeWasm() must be awaited first!");
6121 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
6122 // debug statements here
6124 // 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
6126 export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
6127 if(!isWasmInitialized) {
6128 throw new Error("initializeWasm() must be awaited first!");
6130 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
6131 // debug statements here
6133 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
6135 export function ChannelMessageHandler_handle_closing_signed(this_arg: number, their_node_id: number, msg: number): void {
6136 if(!isWasmInitialized) {
6137 throw new Error("initializeWasm() must be awaited first!");
6139 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
6140 // debug statements here
6142 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
6144 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: number, their_node_id: number, msg: number): void {
6145 if(!isWasmInitialized) {
6146 throw new Error("initializeWasm() must be awaited first!");
6148 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
6149 // debug statements here
6151 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
6153 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: number, their_node_id: number, msg: number): void {
6154 if(!isWasmInitialized) {
6155 throw new Error("initializeWasm() must be awaited first!");
6157 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
6158 // debug statements here
6160 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
6162 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: number, their_node_id: number, msg: number): void {
6163 if(!isWasmInitialized) {
6164 throw new Error("initializeWasm() must be awaited first!");
6166 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
6167 // debug statements here
6169 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
6171 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: number, their_node_id: number, msg: number): void {
6172 if(!isWasmInitialized) {
6173 throw new Error("initializeWasm() must be awaited first!");
6175 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
6176 // debug statements here
6178 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
6180 export function ChannelMessageHandler_handle_commitment_signed(this_arg: number, their_node_id: number, msg: number): void {
6181 if(!isWasmInitialized) {
6182 throw new Error("initializeWasm() must be awaited first!");
6184 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
6185 // debug statements here
6187 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
6189 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: number, their_node_id: number, msg: number): void {
6190 if(!isWasmInitialized) {
6191 throw new Error("initializeWasm() must be awaited first!");
6193 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
6194 // debug statements here
6196 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
6198 export function ChannelMessageHandler_handle_update_fee(this_arg: number, their_node_id: number, msg: number): void {
6199 if(!isWasmInitialized) {
6200 throw new Error("initializeWasm() must be awaited first!");
6202 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
6203 // debug statements here
6205 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
6207 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: number, their_node_id: number, msg: number): void {
6208 if(!isWasmInitialized) {
6209 throw new Error("initializeWasm() must be awaited first!");
6211 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
6212 // debug statements here
6214 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
6216 export function ChannelMessageHandler_peer_disconnected(this_arg: number, their_node_id: number, no_connection_possible: boolean): void {
6217 if(!isWasmInitialized) {
6218 throw new Error("initializeWasm() must be awaited first!");
6220 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
6221 // debug statements here
6223 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
6225 export function ChannelMessageHandler_peer_connected(this_arg: number, their_node_id: number, msg: number): void {
6226 if(!isWasmInitialized) {
6227 throw new Error("initializeWasm() must be awaited first!");
6229 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
6230 // debug statements here
6232 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
6234 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: number, their_node_id: number, msg: number): void {
6235 if(!isWasmInitialized) {
6236 throw new Error("initializeWasm() must be awaited first!");
6238 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
6239 // debug statements here
6241 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
6243 export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: number, msg: number): void {
6244 if(!isWasmInitialized) {
6245 throw new Error("initializeWasm() must be awaited first!");
6247 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
6248 // debug statements here
6250 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
6252 export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: number, msg: number): void {
6253 if(!isWasmInitialized) {
6254 throw new Error("initializeWasm() must be awaited first!");
6256 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
6257 // debug statements here
6260 export interface LDKRoutingMessageHandler {
6261 handle_node_announcement (msg: number): number;
6262 handle_channel_announcement (msg: number): number;
6263 handle_channel_update (msg: number): number;
6264 get_next_channel_announcements (starting_point: bigint, batch_amount: number): number;
6265 get_next_node_announcements (starting_point: number, batch_amount: number): number;
6266 peer_connected (their_node_id: number, init: number): void;
6267 handle_reply_channel_range (their_node_id: number, msg: number): number;
6268 handle_reply_short_channel_ids_end (their_node_id: number, msg: number): number;
6269 handle_query_channel_range (their_node_id: number, msg: number): number;
6270 handle_query_short_channel_ids (their_node_id: number, msg: number): number;
6274 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
6275 if(!isWasmInitialized) {
6276 throw new Error("initializeWasm() must be awaited first!");
6278 var new_obj_idx = js_objs.length;
6279 for (var i = 0; i < js_objs.length; i++) {
6280 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6282 js_objs[i] = new WeakRef(impl);
6283 return wasm.TS_LDKRoutingMessageHandler_new(i);
6285 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
6287 export function RoutingMessageHandler_handle_node_announcement(this_arg: number, msg: number): number {
6288 if(!isWasmInitialized) {
6289 throw new Error("initializeWasm() must be awaited first!");
6291 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
6292 return nativeResponseValue;
6294 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
6296 export function RoutingMessageHandler_handle_channel_announcement(this_arg: number, msg: number): number {
6297 if(!isWasmInitialized) {
6298 throw new Error("initializeWasm() must be awaited first!");
6300 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
6301 return nativeResponseValue;
6303 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
6305 export function RoutingMessageHandler_handle_channel_update(this_arg: number, msg: number): number {
6306 if(!isWasmInitialized) {
6307 throw new Error("initializeWasm() must be awaited first!");
6309 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
6310 return nativeResponseValue;
6312 // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
6314 export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: bigint, batch_amount: number): number {
6315 if(!isWasmInitialized) {
6316 throw new Error("initializeWasm() must be awaited first!");
6318 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
6319 return nativeResponseValue;
6321 // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
6323 export function RoutingMessageHandler_get_next_node_announcements(this_arg: number, starting_point: number, batch_amount: number): number {
6324 if(!isWasmInitialized) {
6325 throw new Error("initializeWasm() must be awaited first!");
6327 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcements(this_arg, starting_point, batch_amount);
6328 return nativeResponseValue;
6330 // void RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
6332 export function RoutingMessageHandler_peer_connected(this_arg: number, their_node_id: number, init: number): void {
6333 if(!isWasmInitialized) {
6334 throw new Error("initializeWasm() must be awaited first!");
6336 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init);
6337 // debug statements here
6339 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
6341 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: number, their_node_id: number, msg: number): number {
6342 if(!isWasmInitialized) {
6343 throw new Error("initializeWasm() must be awaited first!");
6345 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
6346 return nativeResponseValue;
6348 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
6350 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: number, their_node_id: number, msg: number): number {
6351 if(!isWasmInitialized) {
6352 throw new Error("initializeWasm() must be awaited first!");
6354 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
6355 return nativeResponseValue;
6357 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
6359 export function RoutingMessageHandler_handle_query_channel_range(this_arg: number, their_node_id: number, msg: number): number {
6360 if(!isWasmInitialized) {
6361 throw new Error("initializeWasm() must be awaited first!");
6363 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
6364 return nativeResponseValue;
6366 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
6368 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: number, their_node_id: number, msg: number): number {
6369 if(!isWasmInitialized) {
6370 throw new Error("initializeWasm() must be awaited first!");
6372 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
6373 return nativeResponseValue;
6376 export interface LDKCustomMessageReader {
6377 read (message_type: number, buffer: number): number;
6381 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): number {
6382 if(!isWasmInitialized) {
6383 throw new Error("initializeWasm() must be awaited first!");
6385 var new_obj_idx = js_objs.length;
6386 for (var i = 0; i < js_objs.length; i++) {
6387 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6389 js_objs[i] = new WeakRef(impl);
6390 return wasm.TS_LDKCustomMessageReader_new(i);
6392 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
6394 export function CustomMessageReader_read(this_arg: number, message_type: number, buffer: number): number {
6395 if(!isWasmInitialized) {
6396 throw new Error("initializeWasm() must be awaited first!");
6398 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
6399 return nativeResponseValue;
6402 export interface LDKCustomMessageHandler {
6403 handle_custom_message (msg: number, sender_node_id: number): number;
6404 get_and_clear_pending_msg (): number;
6408 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): number {
6409 if(!isWasmInitialized) {
6410 throw new Error("initializeWasm() must be awaited first!");
6412 var new_obj_idx = js_objs.length;
6413 for (var i = 0; i < js_objs.length; i++) {
6414 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6416 js_objs[i] = new WeakRef(impl);
6417 return wasm.TS_LDKCustomMessageHandler_new(i);
6419 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
6421 export function CustomMessageHandler_handle_custom_message(this_arg: number, msg: number, sender_node_id: number): number {
6422 if(!isWasmInitialized) {
6423 throw new Error("initializeWasm() must be awaited first!");
6425 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
6426 return nativeResponseValue;
6428 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
6430 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: number): number {
6431 if(!isWasmInitialized) {
6432 throw new Error("initializeWasm() must be awaited first!");
6434 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
6435 return nativeResponseValue;
6438 export interface LDKSocketDescriptor {
6439 send_data (data: number, resume_read: boolean): number;
6440 disconnect_socket (): void;
6441 eq (other_arg: number): boolean;
6446 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): number {
6447 if(!isWasmInitialized) {
6448 throw new Error("initializeWasm() must be awaited first!");
6450 var new_obj_idx = js_objs.length;
6451 for (var i = 0; i < js_objs.length; i++) {
6452 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6454 js_objs[i] = new WeakRef(impl);
6455 return wasm.TS_LDKSocketDescriptor_new(i);
6457 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
6459 export function SocketDescriptor_send_data(this_arg: number, data: number, resume_read: boolean): number {
6460 if(!isWasmInitialized) {
6461 throw new Error("initializeWasm() must be awaited first!");
6463 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
6464 return nativeResponseValue;
6466 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
6468 export function SocketDescriptor_disconnect_socket(this_arg: number): void {
6469 if(!isWasmInitialized) {
6470 throw new Error("initializeWasm() must be awaited first!");
6472 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
6473 // debug statements here
6475 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
6477 export function SocketDescriptor_hash(this_arg: number): bigint {
6478 if(!isWasmInitialized) {
6479 throw new Error("initializeWasm() must be awaited first!");
6481 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
6482 return nativeResponseValue;
6485 export class LDKEffectiveCapacity {
6486 protected constructor() {}
6489 export function LDKEffectiveCapacity_ty_from_ptr(ptr: number): number {
6490 if(!isWasmInitialized) {
6491 throw new Error("initializeWasm() must be awaited first!");
6493 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
6494 return nativeResponseValue;
6497 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: number): bigint {
6498 if(!isWasmInitialized) {
6499 throw new Error("initializeWasm() must be awaited first!");
6501 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
6502 return nativeResponseValue;
6505 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: number): bigint {
6506 if(!isWasmInitialized) {
6507 throw new Error("initializeWasm() must be awaited first!");
6509 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
6510 return nativeResponseValue;
6513 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: number): bigint {
6514 if(!isWasmInitialized) {
6515 throw new Error("initializeWasm() must be awaited first!");
6517 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
6518 return nativeResponseValue;
6521 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: number): number {
6522 if(!isWasmInitialized) {
6523 throw new Error("initializeWasm() must be awaited first!");
6525 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
6526 return nativeResponseValue;
6529 export interface LDKLockableScore {
6534 export function LDKLockableScore_new(impl: LDKLockableScore): number {
6535 if(!isWasmInitialized) {
6536 throw new Error("initializeWasm() must be awaited first!");
6538 var new_obj_idx = js_objs.length;
6539 for (var i = 0; i < js_objs.length; i++) {
6540 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6542 js_objs[i] = new WeakRef(impl);
6543 return wasm.TS_LDKLockableScore_new(i);
6545 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
6547 export function LockableScore_lock(this_arg: number): number {
6548 if(!isWasmInitialized) {
6549 throw new Error("initializeWasm() must be awaited first!");
6551 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
6552 return nativeResponseValue;
6555 export class LDKFallback {
6556 protected constructor() {}
6559 export function LDKFallback_ty_from_ptr(ptr: number): number {
6560 if(!isWasmInitialized) {
6561 throw new Error("initializeWasm() must be awaited first!");
6563 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
6564 return nativeResponseValue;
6567 export function LDKFallback_SegWitProgram_get_version(ptr: number): number {
6568 if(!isWasmInitialized) {
6569 throw new Error("initializeWasm() must be awaited first!");
6571 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
6572 return nativeResponseValue;
6575 export function LDKFallback_SegWitProgram_get_program(ptr: number): number {
6576 if(!isWasmInitialized) {
6577 throw new Error("initializeWasm() must be awaited first!");
6579 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
6580 return nativeResponseValue;
6583 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: number): number {
6584 if(!isWasmInitialized) {
6585 throw new Error("initializeWasm() must be awaited first!");
6587 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
6588 return nativeResponseValue;
6591 export function LDKFallback_ScriptHash_get_script_hash(ptr: number): number {
6592 if(!isWasmInitialized) {
6593 throw new Error("initializeWasm() must be awaited first!");
6595 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
6596 return nativeResponseValue;
6599 export interface LDKPayer {
6601 first_hops (): number;
6602 send_payment (route: number, payment_hash: number, payment_secret: number): number;
6603 send_spontaneous_payment (route: number, payment_preimage: number): number;
6604 retry_payment (route: number, payment_id: number): number;
6605 abandon_payment (payment_id: number): void;
6609 export function LDKPayer_new(impl: LDKPayer): number {
6610 if(!isWasmInitialized) {
6611 throw new Error("initializeWasm() must be awaited first!");
6613 var new_obj_idx = js_objs.length;
6614 for (var i = 0; i < js_objs.length; i++) {
6615 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6617 js_objs[i] = new WeakRef(impl);
6618 return wasm.TS_LDKPayer_new(i);
6620 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
6622 export function Payer_node_id(this_arg: number): number {
6623 if(!isWasmInitialized) {
6624 throw new Error("initializeWasm() must be awaited first!");
6626 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
6627 return nativeResponseValue;
6629 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
6631 export function Payer_first_hops(this_arg: number): number {
6632 if(!isWasmInitialized) {
6633 throw new Error("initializeWasm() must be awaited first!");
6635 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
6636 return nativeResponseValue;
6638 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret
6640 export function Payer_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
6641 if(!isWasmInitialized) {
6642 throw new Error("initializeWasm() must be awaited first!");
6644 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret);
6645 return nativeResponseValue;
6647 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage
6649 export function Payer_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
6650 if(!isWasmInitialized) {
6651 throw new Error("initializeWasm() must be awaited first!");
6653 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage);
6654 return nativeResponseValue;
6656 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
6658 export function Payer_retry_payment(this_arg: number, route: number, payment_id: number): number {
6659 if(!isWasmInitialized) {
6660 throw new Error("initializeWasm() must be awaited first!");
6662 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
6663 return nativeResponseValue;
6665 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
6667 export function Payer_abandon_payment(this_arg: number, payment_id: number): void {
6668 if(!isWasmInitialized) {
6669 throw new Error("initializeWasm() must be awaited first!");
6671 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
6672 // debug statements here
6675 export interface LDKRouter {
6676 find_route (payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number;
6680 export function LDKRouter_new(impl: LDKRouter): number {
6681 if(!isWasmInitialized) {
6682 throw new Error("initializeWasm() must be awaited first!");
6684 var new_obj_idx = js_objs.length;
6685 for (var i = 0; i < js_objs.length; i++) {
6686 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6688 js_objs[i] = new WeakRef(impl);
6689 return wasm.TS_LDKRouter_new(i);
6691 // 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
6693 export function Router_find_route(this_arg: number, payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number {
6694 if(!isWasmInitialized) {
6695 throw new Error("initializeWasm() must be awaited first!");
6697 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, payment_hash, first_hops, scorer);
6698 return nativeResponseValue;
6701 export class LDKRetry {
6702 protected constructor() {}
6705 export function LDKRetry_ty_from_ptr(ptr: number): number {
6706 if(!isWasmInitialized) {
6707 throw new Error("initializeWasm() must be awaited first!");
6709 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
6710 return nativeResponseValue;
6713 export function LDKRetry_Attempts_get_attempts(ptr: number): number {
6714 if(!isWasmInitialized) {
6715 throw new Error("initializeWasm() must be awaited first!");
6717 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
6718 return nativeResponseValue;
6720 // struct LDKStr _ldk_get_compiled_version(void);
6722 export function _ldk_get_compiled_version(): number {
6723 if(!isWasmInitialized) {
6724 throw new Error("initializeWasm() must be awaited first!");
6726 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
6727 return nativeResponseValue;
6729 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
6731 export function _ldk_c_bindings_get_compiled_version(): number {
6732 if(!isWasmInitialized) {
6733 throw new Error("initializeWasm() must be awaited first!");
6735 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
6736 return nativeResponseValue;
6738 // uintptr_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
6740 export function Bech32Error_clone_ptr(arg: number): number {
6741 if(!isWasmInitialized) {
6742 throw new Error("initializeWasm() must be awaited first!");
6744 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
6745 return nativeResponseValue;
6747 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
6749 export function Bech32Error_clone(orig: number): number {
6750 if(!isWasmInitialized) {
6751 throw new Error("initializeWasm() must be awaited first!");
6753 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
6754 return nativeResponseValue;
6756 // void Bech32Error_free(struct LDKBech32Error o);
6758 export function Bech32Error_free(o: number): void {
6759 if(!isWasmInitialized) {
6760 throw new Error("initializeWasm() must be awaited first!");
6762 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
6763 // debug statements here
6765 // void Transaction_free(struct LDKTransaction _res);
6767 export function Transaction_free(_res: number): void {
6768 if(!isWasmInitialized) {
6769 throw new Error("initializeWasm() must be awaited first!");
6771 const nativeResponseValue = wasm.TS_Transaction_free(_res);
6772 // debug statements here
6774 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
6776 export function TxOut_new(script_pubkey: number, value: bigint): number {
6777 if(!isWasmInitialized) {
6778 throw new Error("initializeWasm() must be awaited first!");
6780 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
6781 return nativeResponseValue;
6783 // void TxOut_free(struct LDKTxOut _res);
6785 export function TxOut_free(_res: number): void {
6786 if(!isWasmInitialized) {
6787 throw new Error("initializeWasm() must be awaited first!");
6789 const nativeResponseValue = wasm.TS_TxOut_free(_res);
6790 // debug statements here
6792 // uintptr_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
6794 export function TxOut_clone_ptr(arg: number): number {
6795 if(!isWasmInitialized) {
6796 throw new Error("initializeWasm() must be awaited first!");
6798 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
6799 return nativeResponseValue;
6801 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
6803 export function TxOut_clone(orig: number): number {
6804 if(!isWasmInitialized) {
6805 throw new Error("initializeWasm() must be awaited first!");
6807 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
6808 return nativeResponseValue;
6810 // void Str_free(struct LDKStr _res);
6812 export function Str_free(_res: number): void {
6813 if(!isWasmInitialized) {
6814 throw new Error("initializeWasm() must be awaited first!");
6816 const nativeResponseValue = wasm.TS_Str_free(_res);
6817 // debug statements here
6819 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
6821 export function CResult_NoneNoneZ_ok(): number {
6822 if(!isWasmInitialized) {
6823 throw new Error("initializeWasm() must be awaited first!");
6825 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
6826 return nativeResponseValue;
6828 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
6830 export function CResult_NoneNoneZ_err(): number {
6831 if(!isWasmInitialized) {
6832 throw new Error("initializeWasm() must be awaited first!");
6834 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
6835 return nativeResponseValue;
6837 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
6839 export function CResult_NoneNoneZ_is_ok(o: number): boolean {
6840 if(!isWasmInitialized) {
6841 throw new Error("initializeWasm() must be awaited first!");
6843 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
6844 return nativeResponseValue;
6846 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
6848 export function CResult_NoneNoneZ_free(_res: number): void {
6849 if(!isWasmInitialized) {
6850 throw new Error("initializeWasm() must be awaited first!");
6852 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
6853 // debug statements here
6855 // uintptr_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
6857 export function CResult_NoneNoneZ_clone_ptr(arg: number): number {
6858 if(!isWasmInitialized) {
6859 throw new Error("initializeWasm() must be awaited first!");
6861 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
6862 return nativeResponseValue;
6864 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
6866 export function CResult_NoneNoneZ_clone(orig: number): number {
6867 if(!isWasmInitialized) {
6868 throw new Error("initializeWasm() must be awaited first!");
6870 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
6871 return nativeResponseValue;
6873 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
6875 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: number): number {
6876 if(!isWasmInitialized) {
6877 throw new Error("initializeWasm() must be awaited first!");
6879 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
6880 return nativeResponseValue;
6882 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
6884 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: number): number {
6885 if(!isWasmInitialized) {
6886 throw new Error("initializeWasm() must be awaited first!");
6888 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
6889 return nativeResponseValue;
6891 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
6893 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: number): boolean {
6894 if(!isWasmInitialized) {
6895 throw new Error("initializeWasm() must be awaited first!");
6897 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
6898 return nativeResponseValue;
6900 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
6902 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: number): void {
6903 if(!isWasmInitialized) {
6904 throw new Error("initializeWasm() must be awaited first!");
6906 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
6907 // debug statements here
6909 // uintptr_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
6911 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: number): number {
6912 if(!isWasmInitialized) {
6913 throw new Error("initializeWasm() must be awaited first!");
6915 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
6916 return nativeResponseValue;
6918 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
6920 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: number): number {
6921 if(!isWasmInitialized) {
6922 throw new Error("initializeWasm() must be awaited first!");
6924 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
6925 return nativeResponseValue;
6927 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
6929 export function CResult_SecretKeyErrorZ_ok(o: number): number {
6930 if(!isWasmInitialized) {
6931 throw new Error("initializeWasm() must be awaited first!");
6933 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
6934 return nativeResponseValue;
6936 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
6938 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): number {
6939 if(!isWasmInitialized) {
6940 throw new Error("initializeWasm() must be awaited first!");
6942 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
6943 return nativeResponseValue;
6945 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
6947 export function CResult_SecretKeyErrorZ_is_ok(o: number): boolean {
6948 if(!isWasmInitialized) {
6949 throw new Error("initializeWasm() must be awaited first!");
6951 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
6952 return nativeResponseValue;
6954 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
6956 export function CResult_SecretKeyErrorZ_free(_res: number): void {
6957 if(!isWasmInitialized) {
6958 throw new Error("initializeWasm() must be awaited first!");
6960 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
6961 // debug statements here
6963 // uintptr_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg);
6965 export function CResult_SecretKeyErrorZ_clone_ptr(arg: number): number {
6966 if(!isWasmInitialized) {
6967 throw new Error("initializeWasm() must be awaited first!");
6969 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone_ptr(arg);
6970 return nativeResponseValue;
6972 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_clone(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR orig);
6974 export function CResult_SecretKeyErrorZ_clone(orig: number): number {
6975 if(!isWasmInitialized) {
6976 throw new Error("initializeWasm() must be awaited first!");
6978 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone(orig);
6979 return nativeResponseValue;
6981 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
6983 export function CResult_PublicKeyErrorZ_ok(o: number): number {
6984 if(!isWasmInitialized) {
6985 throw new Error("initializeWasm() must be awaited first!");
6987 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
6988 return nativeResponseValue;
6990 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
6992 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): number {
6993 if(!isWasmInitialized) {
6994 throw new Error("initializeWasm() must be awaited first!");
6996 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
6997 return nativeResponseValue;
6999 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
7001 export function CResult_PublicKeyErrorZ_is_ok(o: number): boolean {
7002 if(!isWasmInitialized) {
7003 throw new Error("initializeWasm() must be awaited first!");
7005 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
7006 return nativeResponseValue;
7008 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
7010 export function CResult_PublicKeyErrorZ_free(_res: number): void {
7011 if(!isWasmInitialized) {
7012 throw new Error("initializeWasm() must be awaited first!");
7014 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
7015 // debug statements here
7017 // uintptr_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
7019 export function CResult_PublicKeyErrorZ_clone_ptr(arg: number): number {
7020 if(!isWasmInitialized) {
7021 throw new Error("initializeWasm() must be awaited first!");
7023 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
7024 return nativeResponseValue;
7026 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
7028 export function CResult_PublicKeyErrorZ_clone(orig: number): number {
7029 if(!isWasmInitialized) {
7030 throw new Error("initializeWasm() must be awaited first!");
7032 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
7033 return nativeResponseValue;
7035 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
7037 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: number): number {
7038 if(!isWasmInitialized) {
7039 throw new Error("initializeWasm() must be awaited first!");
7041 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
7042 return nativeResponseValue;
7044 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
7046 export function CResult_TxCreationKeysDecodeErrorZ_err(e: number): number {
7047 if(!isWasmInitialized) {
7048 throw new Error("initializeWasm() must be awaited first!");
7050 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
7051 return nativeResponseValue;
7053 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
7055 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: number): boolean {
7056 if(!isWasmInitialized) {
7057 throw new Error("initializeWasm() must be awaited first!");
7059 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
7060 return nativeResponseValue;
7062 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
7064 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
7065 if(!isWasmInitialized) {
7066 throw new Error("initializeWasm() must be awaited first!");
7068 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
7069 // debug statements here
7071 // uintptr_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
7073 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: number): number {
7074 if(!isWasmInitialized) {
7075 throw new Error("initializeWasm() must be awaited first!");
7077 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
7078 return nativeResponseValue;
7080 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
7082 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: number): number {
7083 if(!isWasmInitialized) {
7084 throw new Error("initializeWasm() must be awaited first!");
7086 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
7087 return nativeResponseValue;
7089 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
7091 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: number): number {
7092 if(!isWasmInitialized) {
7093 throw new Error("initializeWasm() must be awaited first!");
7095 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
7096 return nativeResponseValue;
7098 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
7100 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: number): number {
7101 if(!isWasmInitialized) {
7102 throw new Error("initializeWasm() must be awaited first!");
7104 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
7105 return nativeResponseValue;
7107 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
7109 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: number): boolean {
7110 if(!isWasmInitialized) {
7111 throw new Error("initializeWasm() must be awaited first!");
7113 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
7114 return nativeResponseValue;
7116 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
7118 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: number): void {
7119 if(!isWasmInitialized) {
7120 throw new Error("initializeWasm() must be awaited first!");
7122 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
7123 // debug statements here
7125 // uintptr_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
7127 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: number): number {
7128 if(!isWasmInitialized) {
7129 throw new Error("initializeWasm() must be awaited first!");
7131 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
7132 return nativeResponseValue;
7134 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
7136 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: number): number {
7137 if(!isWasmInitialized) {
7138 throw new Error("initializeWasm() must be awaited first!");
7140 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
7141 return nativeResponseValue;
7143 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
7145 export function CResult_TxCreationKeysErrorZ_ok(o: number): number {
7146 if(!isWasmInitialized) {
7147 throw new Error("initializeWasm() must be awaited first!");
7149 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
7150 return nativeResponseValue;
7152 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
7154 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): number {
7155 if(!isWasmInitialized) {
7156 throw new Error("initializeWasm() must be awaited first!");
7158 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
7159 return nativeResponseValue;
7161 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
7163 export function CResult_TxCreationKeysErrorZ_is_ok(o: number): boolean {
7164 if(!isWasmInitialized) {
7165 throw new Error("initializeWasm() must be awaited first!");
7167 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
7168 return nativeResponseValue;
7170 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
7172 export function CResult_TxCreationKeysErrorZ_free(_res: number): void {
7173 if(!isWasmInitialized) {
7174 throw new Error("initializeWasm() must be awaited first!");
7176 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
7177 // debug statements here
7179 // uintptr_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
7181 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: number): number {
7182 if(!isWasmInitialized) {
7183 throw new Error("initializeWasm() must be awaited first!");
7185 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
7186 return nativeResponseValue;
7188 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
7190 export function CResult_TxCreationKeysErrorZ_clone(orig: number): number {
7191 if(!isWasmInitialized) {
7192 throw new Error("initializeWasm() must be awaited first!");
7194 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
7195 return nativeResponseValue;
7197 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
7199 export function COption_u32Z_some(o: number): number {
7200 if(!isWasmInitialized) {
7201 throw new Error("initializeWasm() must be awaited first!");
7203 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
7204 return nativeResponseValue;
7206 // struct LDKCOption_u32Z COption_u32Z_none(void);
7208 export function COption_u32Z_none(): number {
7209 if(!isWasmInitialized) {
7210 throw new Error("initializeWasm() must be awaited first!");
7212 const nativeResponseValue = wasm.TS_COption_u32Z_none();
7213 return nativeResponseValue;
7215 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
7217 export function COption_u32Z_free(_res: number): void {
7218 if(!isWasmInitialized) {
7219 throw new Error("initializeWasm() must be awaited first!");
7221 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
7222 // debug statements here
7224 // uintptr_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
7226 export function COption_u32Z_clone_ptr(arg: number): number {
7227 if(!isWasmInitialized) {
7228 throw new Error("initializeWasm() must be awaited first!");
7230 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
7231 return nativeResponseValue;
7233 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
7235 export function COption_u32Z_clone(orig: number): number {
7236 if(!isWasmInitialized) {
7237 throw new Error("initializeWasm() must be awaited first!");
7239 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
7240 return nativeResponseValue;
7242 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
7244 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
7245 if(!isWasmInitialized) {
7246 throw new Error("initializeWasm() must be awaited first!");
7248 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
7249 return nativeResponseValue;
7251 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
7253 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: number): number {
7254 if(!isWasmInitialized) {
7255 throw new Error("initializeWasm() must be awaited first!");
7257 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
7258 return nativeResponseValue;
7260 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
7262 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: number): boolean {
7263 if(!isWasmInitialized) {
7264 throw new Error("initializeWasm() must be awaited first!");
7266 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
7267 return nativeResponseValue;
7269 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
7271 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: number): void {
7272 if(!isWasmInitialized) {
7273 throw new Error("initializeWasm() must be awaited first!");
7275 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
7276 // debug statements here
7278 // uintptr_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
7280 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: number): number {
7281 if(!isWasmInitialized) {
7282 throw new Error("initializeWasm() must be awaited first!");
7284 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
7285 return nativeResponseValue;
7287 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
7289 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: number): number {
7290 if(!isWasmInitialized) {
7291 throw new Error("initializeWasm() must be awaited first!");
7293 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
7294 return nativeResponseValue;
7296 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
7298 export function COption_NoneZ_some(): COption_NoneZ {
7299 if(!isWasmInitialized) {
7300 throw new Error("initializeWasm() must be awaited first!");
7302 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
7303 return nativeResponseValue;
7305 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
7307 export function COption_NoneZ_none(): COption_NoneZ {
7308 if(!isWasmInitialized) {
7309 throw new Error("initializeWasm() must be awaited first!");
7311 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
7312 return nativeResponseValue;
7314 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
7316 export function COption_NoneZ_free(_res: COption_NoneZ): void {
7317 if(!isWasmInitialized) {
7318 throw new Error("initializeWasm() must be awaited first!");
7320 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
7321 // debug statements here
7323 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
7325 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
7326 if(!isWasmInitialized) {
7327 throw new Error("initializeWasm() must be awaited first!");
7329 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
7330 return nativeResponseValue;
7332 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7334 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: number): number {
7335 if(!isWasmInitialized) {
7336 throw new Error("initializeWasm() must be awaited first!");
7338 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
7339 return nativeResponseValue;
7341 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7343 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
7344 if(!isWasmInitialized) {
7345 throw new Error("initializeWasm() must be awaited first!");
7347 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
7348 return nativeResponseValue;
7350 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
7352 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
7353 if(!isWasmInitialized) {
7354 throw new Error("initializeWasm() must be awaited first!");
7356 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
7357 // debug statements here
7359 // uintptr_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7361 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
7362 if(!isWasmInitialized) {
7363 throw new Error("initializeWasm() must be awaited first!");
7365 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7366 return nativeResponseValue;
7368 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7370 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
7371 if(!isWasmInitialized) {
7372 throw new Error("initializeWasm() must be awaited first!");
7374 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
7375 return nativeResponseValue;
7377 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
7379 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
7380 if(!isWasmInitialized) {
7381 throw new Error("initializeWasm() must be awaited first!");
7383 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
7384 return nativeResponseValue;
7386 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7388 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: number): number {
7389 if(!isWasmInitialized) {
7390 throw new Error("initializeWasm() must be awaited first!");
7392 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
7393 return nativeResponseValue;
7395 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7397 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
7398 if(!isWasmInitialized) {
7399 throw new Error("initializeWasm() must be awaited first!");
7401 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
7402 return nativeResponseValue;
7404 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
7406 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
7407 if(!isWasmInitialized) {
7408 throw new Error("initializeWasm() must be awaited first!");
7410 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
7411 // debug statements here
7413 // uintptr_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7415 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
7416 if(!isWasmInitialized) {
7417 throw new Error("initializeWasm() must be awaited first!");
7419 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7420 return nativeResponseValue;
7422 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7424 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
7425 if(!isWasmInitialized) {
7426 throw new Error("initializeWasm() must be awaited first!");
7428 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
7429 return nativeResponseValue;
7431 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
7433 export function CVec_SignatureZ_free(_res: number): void {
7434 if(!isWasmInitialized) {
7435 throw new Error("initializeWasm() must be awaited first!");
7437 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
7438 // debug statements here
7440 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
7442 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7443 if(!isWasmInitialized) {
7444 throw new Error("initializeWasm() must be awaited first!");
7446 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
7447 return nativeResponseValue;
7449 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7451 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: number): number {
7452 if(!isWasmInitialized) {
7453 throw new Error("initializeWasm() must be awaited first!");
7455 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
7456 return nativeResponseValue;
7458 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7460 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7461 if(!isWasmInitialized) {
7462 throw new Error("initializeWasm() must be awaited first!");
7464 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
7465 return nativeResponseValue;
7467 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
7469 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7470 if(!isWasmInitialized) {
7471 throw new Error("initializeWasm() must be awaited first!");
7473 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
7474 // debug statements here
7476 // uintptr_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7478 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7479 if(!isWasmInitialized) {
7480 throw new Error("initializeWasm() must be awaited first!");
7482 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7483 return nativeResponseValue;
7485 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7487 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7488 if(!isWasmInitialized) {
7489 throw new Error("initializeWasm() must be awaited first!");
7491 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
7492 return nativeResponseValue;
7494 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
7496 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7497 if(!isWasmInitialized) {
7498 throw new Error("initializeWasm() must be awaited first!");
7500 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
7501 return nativeResponseValue;
7503 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7505 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: number): number {
7506 if(!isWasmInitialized) {
7507 throw new Error("initializeWasm() must be awaited first!");
7509 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
7510 return nativeResponseValue;
7512 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7514 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7515 if(!isWasmInitialized) {
7516 throw new Error("initializeWasm() must be awaited first!");
7518 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
7519 return nativeResponseValue;
7521 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
7523 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7524 if(!isWasmInitialized) {
7525 throw new Error("initializeWasm() must be awaited first!");
7527 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
7528 // debug statements here
7530 // uintptr_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7532 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7533 if(!isWasmInitialized) {
7534 throw new Error("initializeWasm() must be awaited first!");
7536 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7537 return nativeResponseValue;
7539 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7541 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7542 if(!isWasmInitialized) {
7543 throw new Error("initializeWasm() must be awaited first!");
7545 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
7546 return nativeResponseValue;
7548 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
7550 export function CResult_TrustedClosingTransactionNoneZ_ok(o: number): number {
7551 if(!isWasmInitialized) {
7552 throw new Error("initializeWasm() must be awaited first!");
7554 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
7555 return nativeResponseValue;
7557 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
7559 export function CResult_TrustedClosingTransactionNoneZ_err(): number {
7560 if(!isWasmInitialized) {
7561 throw new Error("initializeWasm() must be awaited first!");
7563 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
7564 return nativeResponseValue;
7566 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
7568 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: number): boolean {
7569 if(!isWasmInitialized) {
7570 throw new Error("initializeWasm() must be awaited first!");
7572 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
7573 return nativeResponseValue;
7575 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
7577 export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
7578 if(!isWasmInitialized) {
7579 throw new Error("initializeWasm() must be awaited first!");
7581 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
7582 // debug statements here
7584 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
7586 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: number): number {
7587 if(!isWasmInitialized) {
7588 throw new Error("initializeWasm() must be awaited first!");
7590 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
7591 return nativeResponseValue;
7593 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7595 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: number): number {
7596 if(!isWasmInitialized) {
7597 throw new Error("initializeWasm() must be awaited first!");
7599 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
7600 return nativeResponseValue;
7602 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7604 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7605 if(!isWasmInitialized) {
7606 throw new Error("initializeWasm() must be awaited first!");
7608 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
7609 return nativeResponseValue;
7611 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
7613 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: number): void {
7614 if(!isWasmInitialized) {
7615 throw new Error("initializeWasm() must be awaited first!");
7617 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
7618 // debug statements here
7620 // uintptr_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7622 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7623 if(!isWasmInitialized) {
7624 throw new Error("initializeWasm() must be awaited first!");
7626 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7627 return nativeResponseValue;
7629 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7631 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7632 if(!isWasmInitialized) {
7633 throw new Error("initializeWasm() must be awaited first!");
7635 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
7636 return nativeResponseValue;
7638 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
7640 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
7641 if(!isWasmInitialized) {
7642 throw new Error("initializeWasm() must be awaited first!");
7644 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
7645 return nativeResponseValue;
7647 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
7649 export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
7650 if(!isWasmInitialized) {
7651 throw new Error("initializeWasm() must be awaited first!");
7653 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
7654 return nativeResponseValue;
7656 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
7658 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: number): boolean {
7659 if(!isWasmInitialized) {
7660 throw new Error("initializeWasm() must be awaited first!");
7662 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
7663 return nativeResponseValue;
7665 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
7667 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
7668 if(!isWasmInitialized) {
7669 throw new Error("initializeWasm() must be awaited first!");
7671 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
7672 // debug statements here
7674 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
7676 export function CResult_CVec_SignatureZNoneZ_ok(o: number): number {
7677 if(!isWasmInitialized) {
7678 throw new Error("initializeWasm() must be awaited first!");
7680 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
7681 return nativeResponseValue;
7683 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
7685 export function CResult_CVec_SignatureZNoneZ_err(): number {
7686 if(!isWasmInitialized) {
7687 throw new Error("initializeWasm() must be awaited first!");
7689 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
7690 return nativeResponseValue;
7692 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
7694 export function CResult_CVec_SignatureZNoneZ_is_ok(o: number): boolean {
7695 if(!isWasmInitialized) {
7696 throw new Error("initializeWasm() must be awaited first!");
7698 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
7699 return nativeResponseValue;
7701 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
7703 export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
7704 if(!isWasmInitialized) {
7705 throw new Error("initializeWasm() must be awaited first!");
7707 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
7708 // debug statements here
7710 // uintptr_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
7712 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: number): number {
7713 if(!isWasmInitialized) {
7714 throw new Error("initializeWasm() must be awaited first!");
7716 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
7717 return nativeResponseValue;
7719 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
7721 export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
7722 if(!isWasmInitialized) {
7723 throw new Error("initializeWasm() must be awaited first!");
7725 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
7726 return nativeResponseValue;
7728 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
7730 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: number): number {
7731 if(!isWasmInitialized) {
7732 throw new Error("initializeWasm() must be awaited first!");
7734 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
7735 return nativeResponseValue;
7737 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
7739 export function CResult_ShutdownScriptDecodeErrorZ_err(e: number): number {
7740 if(!isWasmInitialized) {
7741 throw new Error("initializeWasm() must be awaited first!");
7743 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
7744 return nativeResponseValue;
7746 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
7748 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: number): boolean {
7749 if(!isWasmInitialized) {
7750 throw new Error("initializeWasm() must be awaited first!");
7752 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
7753 return nativeResponseValue;
7755 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
7757 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
7758 if(!isWasmInitialized) {
7759 throw new Error("initializeWasm() must be awaited first!");
7761 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
7762 // debug statements here
7764 // uintptr_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
7766 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: number): number {
7767 if(!isWasmInitialized) {
7768 throw new Error("initializeWasm() must be awaited first!");
7770 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
7771 return nativeResponseValue;
7773 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
7775 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
7776 if(!isWasmInitialized) {
7777 throw new Error("initializeWasm() must be awaited first!");
7779 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
7780 return nativeResponseValue;
7782 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
7784 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: number): number {
7785 if(!isWasmInitialized) {
7786 throw new Error("initializeWasm() must be awaited first!");
7788 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
7789 return nativeResponseValue;
7791 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
7793 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: number): number {
7794 if(!isWasmInitialized) {
7795 throw new Error("initializeWasm() must be awaited first!");
7797 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
7798 return nativeResponseValue;
7800 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
7802 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: number): boolean {
7803 if(!isWasmInitialized) {
7804 throw new Error("initializeWasm() must be awaited first!");
7806 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
7807 return nativeResponseValue;
7809 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
7811 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
7812 if(!isWasmInitialized) {
7813 throw new Error("initializeWasm() must be awaited first!");
7815 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
7816 // debug statements here
7818 // uintptr_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
7820 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: number): number {
7821 if(!isWasmInitialized) {
7822 throw new Error("initializeWasm() must be awaited first!");
7824 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
7825 return nativeResponseValue;
7827 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
7829 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: number): number {
7830 if(!isWasmInitialized) {
7831 throw new Error("initializeWasm() must be awaited first!");
7833 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
7834 return nativeResponseValue;
7836 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
7838 export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
7839 if(!isWasmInitialized) {
7840 throw new Error("initializeWasm() must be awaited first!");
7842 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
7843 return nativeResponseValue;
7845 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
7847 export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
7848 if(!isWasmInitialized) {
7849 throw new Error("initializeWasm() must be awaited first!");
7851 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
7852 return nativeResponseValue;
7854 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
7856 export function CResult_RouteHopDecodeErrorZ_is_ok(o: number): boolean {
7857 if(!isWasmInitialized) {
7858 throw new Error("initializeWasm() must be awaited first!");
7860 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
7861 return nativeResponseValue;
7863 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
7865 export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
7866 if(!isWasmInitialized) {
7867 throw new Error("initializeWasm() must be awaited first!");
7869 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
7870 // debug statements here
7872 // uintptr_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
7874 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: number): number {
7875 if(!isWasmInitialized) {
7876 throw new Error("initializeWasm() must be awaited first!");
7878 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
7879 return nativeResponseValue;
7881 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
7883 export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
7884 if(!isWasmInitialized) {
7885 throw new Error("initializeWasm() must be awaited first!");
7887 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
7888 return nativeResponseValue;
7890 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
7892 export function CVec_RouteHopZ_free(_res: number): void {
7893 if(!isWasmInitialized) {
7894 throw new Error("initializeWasm() must be awaited first!");
7896 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
7897 // debug statements here
7899 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
7901 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
7902 if(!isWasmInitialized) {
7903 throw new Error("initializeWasm() must be awaited first!");
7905 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
7906 // debug statements here
7908 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
7910 export function CResult_RouteDecodeErrorZ_ok(o: number): number {
7911 if(!isWasmInitialized) {
7912 throw new Error("initializeWasm() must be awaited first!");
7914 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
7915 return nativeResponseValue;
7917 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
7919 export function CResult_RouteDecodeErrorZ_err(e: number): number {
7920 if(!isWasmInitialized) {
7921 throw new Error("initializeWasm() must be awaited first!");
7923 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
7924 return nativeResponseValue;
7926 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
7928 export function CResult_RouteDecodeErrorZ_is_ok(o: number): boolean {
7929 if(!isWasmInitialized) {
7930 throw new Error("initializeWasm() must be awaited first!");
7932 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
7933 return nativeResponseValue;
7935 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
7937 export function CResult_RouteDecodeErrorZ_free(_res: number): void {
7938 if(!isWasmInitialized) {
7939 throw new Error("initializeWasm() must be awaited first!");
7941 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
7942 // debug statements here
7944 // uintptr_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
7946 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: number): number {
7947 if(!isWasmInitialized) {
7948 throw new Error("initializeWasm() must be awaited first!");
7950 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
7951 return nativeResponseValue;
7953 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
7955 export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
7956 if(!isWasmInitialized) {
7957 throw new Error("initializeWasm() must be awaited first!");
7959 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
7960 return nativeResponseValue;
7962 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
7964 export function CResult_RouteParametersDecodeErrorZ_ok(o: number): number {
7965 if(!isWasmInitialized) {
7966 throw new Error("initializeWasm() must be awaited first!");
7968 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
7969 return nativeResponseValue;
7971 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
7973 export function CResult_RouteParametersDecodeErrorZ_err(e: number): number {
7974 if(!isWasmInitialized) {
7975 throw new Error("initializeWasm() must be awaited first!");
7977 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
7978 return nativeResponseValue;
7980 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
7982 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: number): boolean {
7983 if(!isWasmInitialized) {
7984 throw new Error("initializeWasm() must be awaited first!");
7986 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
7987 return nativeResponseValue;
7989 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
7991 export function CResult_RouteParametersDecodeErrorZ_free(_res: number): void {
7992 if(!isWasmInitialized) {
7993 throw new Error("initializeWasm() must be awaited first!");
7995 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
7996 // debug statements here
7998 // uintptr_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
8000 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: number): number {
8001 if(!isWasmInitialized) {
8002 throw new Error("initializeWasm() must be awaited first!");
8004 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
8005 return nativeResponseValue;
8007 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
8009 export function CResult_RouteParametersDecodeErrorZ_clone(orig: number): number {
8010 if(!isWasmInitialized) {
8011 throw new Error("initializeWasm() must be awaited first!");
8013 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
8014 return nativeResponseValue;
8016 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
8018 export function CVec_RouteHintZ_free(_res: number): void {
8019 if(!isWasmInitialized) {
8020 throw new Error("initializeWasm() must be awaited first!");
8022 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
8023 // debug statements here
8025 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
8027 export function COption_u64Z_some(o: bigint): number {
8028 if(!isWasmInitialized) {
8029 throw new Error("initializeWasm() must be awaited first!");
8031 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
8032 return nativeResponseValue;
8034 // struct LDKCOption_u64Z COption_u64Z_none(void);
8036 export function COption_u64Z_none(): number {
8037 if(!isWasmInitialized) {
8038 throw new Error("initializeWasm() must be awaited first!");
8040 const nativeResponseValue = wasm.TS_COption_u64Z_none();
8041 return nativeResponseValue;
8043 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
8045 export function COption_u64Z_free(_res: number): void {
8046 if(!isWasmInitialized) {
8047 throw new Error("initializeWasm() must be awaited first!");
8049 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
8050 // debug statements here
8052 // uintptr_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
8054 export function COption_u64Z_clone_ptr(arg: number): number {
8055 if(!isWasmInitialized) {
8056 throw new Error("initializeWasm() must be awaited first!");
8058 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
8059 return nativeResponseValue;
8061 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
8063 export function COption_u64Z_clone(orig: number): number {
8064 if(!isWasmInitialized) {
8065 throw new Error("initializeWasm() must be awaited first!");
8067 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
8068 return nativeResponseValue;
8070 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
8072 export function CVec_u64Z_free(_res: number): void {
8073 if(!isWasmInitialized) {
8074 throw new Error("initializeWasm() must be awaited first!");
8076 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
8077 // debug statements here
8079 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
8081 export function CResult_PaymentParametersDecodeErrorZ_ok(o: number): number {
8082 if(!isWasmInitialized) {
8083 throw new Error("initializeWasm() must be awaited first!");
8085 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
8086 return nativeResponseValue;
8088 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
8090 export function CResult_PaymentParametersDecodeErrorZ_err(e: number): number {
8091 if(!isWasmInitialized) {
8092 throw new Error("initializeWasm() must be awaited first!");
8094 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
8095 return nativeResponseValue;
8097 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
8099 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: number): boolean {
8100 if(!isWasmInitialized) {
8101 throw new Error("initializeWasm() must be awaited first!");
8103 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
8104 return nativeResponseValue;
8106 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
8108 export function CResult_PaymentParametersDecodeErrorZ_free(_res: number): void {
8109 if(!isWasmInitialized) {
8110 throw new Error("initializeWasm() must be awaited first!");
8112 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
8113 // debug statements here
8115 // uintptr_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
8117 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: number): number {
8118 if(!isWasmInitialized) {
8119 throw new Error("initializeWasm() must be awaited first!");
8121 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
8122 return nativeResponseValue;
8124 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
8126 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: number): number {
8127 if(!isWasmInitialized) {
8128 throw new Error("initializeWasm() must be awaited first!");
8130 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
8131 return nativeResponseValue;
8133 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
8135 export function CVec_RouteHintHopZ_free(_res: number): void {
8136 if(!isWasmInitialized) {
8137 throw new Error("initializeWasm() must be awaited first!");
8139 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
8140 // debug statements here
8142 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
8144 export function CResult_RouteHintDecodeErrorZ_ok(o: number): number {
8145 if(!isWasmInitialized) {
8146 throw new Error("initializeWasm() must be awaited first!");
8148 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
8149 return nativeResponseValue;
8151 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
8153 export function CResult_RouteHintDecodeErrorZ_err(e: number): number {
8154 if(!isWasmInitialized) {
8155 throw new Error("initializeWasm() must be awaited first!");
8157 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
8158 return nativeResponseValue;
8160 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
8162 export function CResult_RouteHintDecodeErrorZ_is_ok(o: number): boolean {
8163 if(!isWasmInitialized) {
8164 throw new Error("initializeWasm() must be awaited first!");
8166 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
8167 return nativeResponseValue;
8169 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
8171 export function CResult_RouteHintDecodeErrorZ_free(_res: number): void {
8172 if(!isWasmInitialized) {
8173 throw new Error("initializeWasm() must be awaited first!");
8175 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
8176 // debug statements here
8178 // uintptr_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
8180 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: number): number {
8181 if(!isWasmInitialized) {
8182 throw new Error("initializeWasm() must be awaited first!");
8184 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
8185 return nativeResponseValue;
8187 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
8189 export function CResult_RouteHintDecodeErrorZ_clone(orig: number): number {
8190 if(!isWasmInitialized) {
8191 throw new Error("initializeWasm() must be awaited first!");
8193 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
8194 return nativeResponseValue;
8196 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
8198 export function CResult_RouteHintHopDecodeErrorZ_ok(o: number): number {
8199 if(!isWasmInitialized) {
8200 throw new Error("initializeWasm() must be awaited first!");
8202 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
8203 return nativeResponseValue;
8205 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
8207 export function CResult_RouteHintHopDecodeErrorZ_err(e: number): number {
8208 if(!isWasmInitialized) {
8209 throw new Error("initializeWasm() must be awaited first!");
8211 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
8212 return nativeResponseValue;
8214 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
8216 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: number): boolean {
8217 if(!isWasmInitialized) {
8218 throw new Error("initializeWasm() must be awaited first!");
8220 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
8221 return nativeResponseValue;
8223 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
8225 export function CResult_RouteHintHopDecodeErrorZ_free(_res: number): void {
8226 if(!isWasmInitialized) {
8227 throw new Error("initializeWasm() must be awaited first!");
8229 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
8230 // debug statements here
8232 // uintptr_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
8234 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: number): number {
8235 if(!isWasmInitialized) {
8236 throw new Error("initializeWasm() must be awaited first!");
8238 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
8239 return nativeResponseValue;
8241 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
8243 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: number): number {
8244 if(!isWasmInitialized) {
8245 throw new Error("initializeWasm() must be awaited first!");
8247 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
8248 return nativeResponseValue;
8250 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
8252 export function CVec_ChannelDetailsZ_free(_res: number): void {
8253 if(!isWasmInitialized) {
8254 throw new Error("initializeWasm() must be awaited first!");
8256 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
8257 // debug statements here
8259 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
8261 export function CResult_RouteLightningErrorZ_ok(o: number): number {
8262 if(!isWasmInitialized) {
8263 throw new Error("initializeWasm() must be awaited first!");
8265 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
8266 return nativeResponseValue;
8268 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
8270 export function CResult_RouteLightningErrorZ_err(e: number): number {
8271 if(!isWasmInitialized) {
8272 throw new Error("initializeWasm() must be awaited first!");
8274 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
8275 return nativeResponseValue;
8277 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
8279 export function CResult_RouteLightningErrorZ_is_ok(o: number): boolean {
8280 if(!isWasmInitialized) {
8281 throw new Error("initializeWasm() must be awaited first!");
8283 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
8284 return nativeResponseValue;
8286 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
8288 export function CResult_RouteLightningErrorZ_free(_res: number): void {
8289 if(!isWasmInitialized) {
8290 throw new Error("initializeWasm() must be awaited first!");
8292 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
8293 // debug statements here
8295 // uintptr_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
8297 export function CResult_RouteLightningErrorZ_clone_ptr(arg: number): number {
8298 if(!isWasmInitialized) {
8299 throw new Error("initializeWasm() must be awaited first!");
8301 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
8302 return nativeResponseValue;
8304 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
8306 export function CResult_RouteLightningErrorZ_clone(orig: number): number {
8307 if(!isWasmInitialized) {
8308 throw new Error("initializeWasm() must be awaited first!");
8310 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
8311 return nativeResponseValue;
8313 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
8315 export function CVec_PublicKeyZ_free(_res: number): void {
8316 if(!isWasmInitialized) {
8317 throw new Error("initializeWasm() must be awaited first!");
8319 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
8320 // debug statements here
8322 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
8324 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: number): number {
8325 if(!isWasmInitialized) {
8326 throw new Error("initializeWasm() must be awaited first!");
8328 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
8329 return nativeResponseValue;
8331 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
8333 export function CResult_PaymentPurposeDecodeErrorZ_err(e: number): number {
8334 if(!isWasmInitialized) {
8335 throw new Error("initializeWasm() must be awaited first!");
8337 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
8338 return nativeResponseValue;
8340 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
8342 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: number): boolean {
8343 if(!isWasmInitialized) {
8344 throw new Error("initializeWasm() must be awaited first!");
8346 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
8347 return nativeResponseValue;
8349 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
8351 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: number): void {
8352 if(!isWasmInitialized) {
8353 throw new Error("initializeWasm() must be awaited first!");
8355 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
8356 // debug statements here
8358 // uintptr_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
8360 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: number): number {
8361 if(!isWasmInitialized) {
8362 throw new Error("initializeWasm() must be awaited first!");
8364 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
8365 return nativeResponseValue;
8367 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
8369 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: number): number {
8370 if(!isWasmInitialized) {
8371 throw new Error("initializeWasm() must be awaited first!");
8373 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
8374 return nativeResponseValue;
8376 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
8378 export function COption_ClosureReasonZ_some(o: number): number {
8379 if(!isWasmInitialized) {
8380 throw new Error("initializeWasm() must be awaited first!");
8382 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
8383 return nativeResponseValue;
8385 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
8387 export function COption_ClosureReasonZ_none(): number {
8388 if(!isWasmInitialized) {
8389 throw new Error("initializeWasm() must be awaited first!");
8391 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
8392 return nativeResponseValue;
8394 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
8396 export function COption_ClosureReasonZ_free(_res: number): void {
8397 if(!isWasmInitialized) {
8398 throw new Error("initializeWasm() must be awaited first!");
8400 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
8401 // debug statements here
8403 // uintptr_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
8405 export function COption_ClosureReasonZ_clone_ptr(arg: number): number {
8406 if(!isWasmInitialized) {
8407 throw new Error("initializeWasm() must be awaited first!");
8409 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
8410 return nativeResponseValue;
8412 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
8414 export function COption_ClosureReasonZ_clone(orig: number): number {
8415 if(!isWasmInitialized) {
8416 throw new Error("initializeWasm() must be awaited first!");
8418 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
8419 return nativeResponseValue;
8421 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
8423 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: number): number {
8424 if(!isWasmInitialized) {
8425 throw new Error("initializeWasm() must be awaited first!");
8427 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
8428 return nativeResponseValue;
8430 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
8432 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: number): number {
8433 if(!isWasmInitialized) {
8434 throw new Error("initializeWasm() must be awaited first!");
8436 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
8437 return nativeResponseValue;
8439 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
8441 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: number): boolean {
8442 if(!isWasmInitialized) {
8443 throw new Error("initializeWasm() must be awaited first!");
8445 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
8446 return nativeResponseValue;
8448 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
8450 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: number): void {
8451 if(!isWasmInitialized) {
8452 throw new Error("initializeWasm() must be awaited first!");
8454 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
8455 // debug statements here
8457 // uintptr_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
8459 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: number): number {
8460 if(!isWasmInitialized) {
8461 throw new Error("initializeWasm() must be awaited first!");
8463 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
8464 return nativeResponseValue;
8466 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
8468 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: number): number {
8469 if(!isWasmInitialized) {
8470 throw new Error("initializeWasm() must be awaited first!");
8472 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
8473 return nativeResponseValue;
8475 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_some(struct LDKHTLCDestination o);
8477 export function COption_HTLCDestinationZ_some(o: number): number {
8478 if(!isWasmInitialized) {
8479 throw new Error("initializeWasm() must be awaited first!");
8481 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_some(o);
8482 return nativeResponseValue;
8484 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_none(void);
8486 export function COption_HTLCDestinationZ_none(): number {
8487 if(!isWasmInitialized) {
8488 throw new Error("initializeWasm() must be awaited first!");
8490 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_none();
8491 return nativeResponseValue;
8493 // void COption_HTLCDestinationZ_free(struct LDKCOption_HTLCDestinationZ _res);
8495 export function COption_HTLCDestinationZ_free(_res: number): void {
8496 if(!isWasmInitialized) {
8497 throw new Error("initializeWasm() must be awaited first!");
8499 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_free(_res);
8500 // debug statements here
8502 // uintptr_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg);
8504 export function COption_HTLCDestinationZ_clone_ptr(arg: number): number {
8505 if(!isWasmInitialized) {
8506 throw new Error("initializeWasm() must be awaited first!");
8508 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone_ptr(arg);
8509 return nativeResponseValue;
8511 // struct LDKCOption_HTLCDestinationZ COption_HTLCDestinationZ_clone(const struct LDKCOption_HTLCDestinationZ *NONNULL_PTR orig);
8513 export function COption_HTLCDestinationZ_clone(orig: number): number {
8514 if(!isWasmInitialized) {
8515 throw new Error("initializeWasm() must be awaited first!");
8517 const nativeResponseValue = wasm.TS_COption_HTLCDestinationZ_clone(orig);
8518 return nativeResponseValue;
8520 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_ok(struct LDKCOption_HTLCDestinationZ o);
8522 export function CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o: number): number {
8523 if(!isWasmInitialized) {
8524 throw new Error("initializeWasm() must be awaited first!");
8526 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o);
8527 return nativeResponseValue;
8529 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_err(struct LDKDecodeError e);
8531 export function CResult_COption_HTLCDestinationZDecodeErrorZ_err(e: number): number {
8532 if(!isWasmInitialized) {
8533 throw new Error("initializeWasm() must be awaited first!");
8535 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(e);
8536 return nativeResponseValue;
8538 // bool CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR o);
8540 export function CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o: number): boolean {
8541 if(!isWasmInitialized) {
8542 throw new Error("initializeWasm() must be awaited first!");
8544 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o);
8545 return nativeResponseValue;
8547 // void CResult_COption_HTLCDestinationZDecodeErrorZ_free(struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res);
8549 export function CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res: number): void {
8550 if(!isWasmInitialized) {
8551 throw new Error("initializeWasm() must be awaited first!");
8553 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res);
8554 // debug statements here
8556 // uintptr_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg);
8558 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg: number): number {
8559 if(!isWasmInitialized) {
8560 throw new Error("initializeWasm() must be awaited first!");
8562 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg);
8563 return nativeResponseValue;
8565 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ CResult_COption_HTLCDestinationZDecodeErrorZ_clone(const struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR orig);
8567 export function CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig: number): number {
8568 if(!isWasmInitialized) {
8569 throw new Error("initializeWasm() must be awaited first!");
8571 const nativeResponseValue = wasm.TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig);
8572 return nativeResponseValue;
8574 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
8576 export function COption_NetworkUpdateZ_some(o: number): number {
8577 if(!isWasmInitialized) {
8578 throw new Error("initializeWasm() must be awaited first!");
8580 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
8581 return nativeResponseValue;
8583 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
8585 export function COption_NetworkUpdateZ_none(): number {
8586 if(!isWasmInitialized) {
8587 throw new Error("initializeWasm() must be awaited first!");
8589 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
8590 return nativeResponseValue;
8592 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
8594 export function COption_NetworkUpdateZ_free(_res: number): void {
8595 if(!isWasmInitialized) {
8596 throw new Error("initializeWasm() must be awaited first!");
8598 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
8599 // debug statements here
8601 // uintptr_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
8603 export function COption_NetworkUpdateZ_clone_ptr(arg: number): number {
8604 if(!isWasmInitialized) {
8605 throw new Error("initializeWasm() must be awaited first!");
8607 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
8608 return nativeResponseValue;
8610 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
8612 export function COption_NetworkUpdateZ_clone(orig: number): number {
8613 if(!isWasmInitialized) {
8614 throw new Error("initializeWasm() must be awaited first!");
8616 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
8617 return nativeResponseValue;
8619 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
8621 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
8622 if(!isWasmInitialized) {
8623 throw new Error("initializeWasm() must be awaited first!");
8625 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
8626 // debug statements here
8628 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
8630 export function COption_EventZ_some(o: number): number {
8631 if(!isWasmInitialized) {
8632 throw new Error("initializeWasm() must be awaited first!");
8634 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
8635 return nativeResponseValue;
8637 // struct LDKCOption_EventZ COption_EventZ_none(void);
8639 export function COption_EventZ_none(): number {
8640 if(!isWasmInitialized) {
8641 throw new Error("initializeWasm() must be awaited first!");
8643 const nativeResponseValue = wasm.TS_COption_EventZ_none();
8644 return nativeResponseValue;
8646 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
8648 export function COption_EventZ_free(_res: number): void {
8649 if(!isWasmInitialized) {
8650 throw new Error("initializeWasm() must be awaited first!");
8652 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
8653 // debug statements here
8655 // uintptr_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
8657 export function COption_EventZ_clone_ptr(arg: number): number {
8658 if(!isWasmInitialized) {
8659 throw new Error("initializeWasm() must be awaited first!");
8661 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
8662 return nativeResponseValue;
8664 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
8666 export function COption_EventZ_clone(orig: number): number {
8667 if(!isWasmInitialized) {
8668 throw new Error("initializeWasm() must be awaited first!");
8670 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
8671 return nativeResponseValue;
8673 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
8675 export function CResult_COption_EventZDecodeErrorZ_ok(o: number): number {
8676 if(!isWasmInitialized) {
8677 throw new Error("initializeWasm() must be awaited first!");
8679 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
8680 return nativeResponseValue;
8682 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
8684 export function CResult_COption_EventZDecodeErrorZ_err(e: number): number {
8685 if(!isWasmInitialized) {
8686 throw new Error("initializeWasm() must be awaited first!");
8688 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
8689 return nativeResponseValue;
8691 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
8693 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: number): boolean {
8694 if(!isWasmInitialized) {
8695 throw new Error("initializeWasm() must be awaited first!");
8697 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
8698 return nativeResponseValue;
8700 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
8702 export function CResult_COption_EventZDecodeErrorZ_free(_res: number): void {
8703 if(!isWasmInitialized) {
8704 throw new Error("initializeWasm() must be awaited first!");
8706 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
8707 // debug statements here
8709 // uintptr_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
8711 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: number): number {
8712 if(!isWasmInitialized) {
8713 throw new Error("initializeWasm() must be awaited first!");
8715 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
8716 return nativeResponseValue;
8718 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
8720 export function CResult_COption_EventZDecodeErrorZ_clone(orig: number): number {
8721 if(!isWasmInitialized) {
8722 throw new Error("initializeWasm() must be awaited first!");
8724 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
8725 return nativeResponseValue;
8727 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
8729 export function CVec_MessageSendEventZ_free(_res: number): void {
8730 if(!isWasmInitialized) {
8731 throw new Error("initializeWasm() must be awaited first!");
8733 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
8734 // debug statements here
8736 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
8738 export function CResult_TxOutAccessErrorZ_ok(o: number): number {
8739 if(!isWasmInitialized) {
8740 throw new Error("initializeWasm() must be awaited first!");
8742 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
8743 return nativeResponseValue;
8745 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
8747 export function CResult_TxOutAccessErrorZ_err(e: AccessError): number {
8748 if(!isWasmInitialized) {
8749 throw new Error("initializeWasm() must be awaited first!");
8751 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
8752 return nativeResponseValue;
8754 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
8756 export function CResult_TxOutAccessErrorZ_is_ok(o: number): boolean {
8757 if(!isWasmInitialized) {
8758 throw new Error("initializeWasm() must be awaited first!");
8760 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
8761 return nativeResponseValue;
8763 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
8765 export function CResult_TxOutAccessErrorZ_free(_res: number): void {
8766 if(!isWasmInitialized) {
8767 throw new Error("initializeWasm() must be awaited first!");
8769 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
8770 // debug statements here
8772 // uintptr_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
8774 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: number): number {
8775 if(!isWasmInitialized) {
8776 throw new Error("initializeWasm() must be awaited first!");
8778 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
8779 return nativeResponseValue;
8781 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
8783 export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
8784 if(!isWasmInitialized) {
8785 throw new Error("initializeWasm() must be awaited first!");
8787 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
8788 return nativeResponseValue;
8790 // uintptr_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
8792 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: number): number {
8793 if(!isWasmInitialized) {
8794 throw new Error("initializeWasm() must be awaited first!");
8796 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
8797 return nativeResponseValue;
8799 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
8801 export function C2Tuple_usizeTransactionZ_clone(orig: number): number {
8802 if(!isWasmInitialized) {
8803 throw new Error("initializeWasm() must be awaited first!");
8805 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
8806 return nativeResponseValue;
8808 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
8810 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): number {
8811 if(!isWasmInitialized) {
8812 throw new Error("initializeWasm() must be awaited first!");
8814 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
8815 return nativeResponseValue;
8817 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
8819 export function C2Tuple_usizeTransactionZ_free(_res: number): void {
8820 if(!isWasmInitialized) {
8821 throw new Error("initializeWasm() must be awaited first!");
8823 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
8824 // debug statements here
8826 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
8828 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8829 if(!isWasmInitialized) {
8830 throw new Error("initializeWasm() must be awaited first!");
8832 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
8833 // debug statements here
8835 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
8837 export function CVec_TxidZ_free(_res: number): void {
8838 if(!isWasmInitialized) {
8839 throw new Error("initializeWasm() must be awaited first!");
8841 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
8842 // debug statements here
8844 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
8846 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
8847 if(!isWasmInitialized) {
8848 throw new Error("initializeWasm() must be awaited first!");
8850 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
8851 return nativeResponseValue;
8853 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
8855 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): number {
8856 if(!isWasmInitialized) {
8857 throw new Error("initializeWasm() must be awaited first!");
8859 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
8860 return nativeResponseValue;
8862 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
8864 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: number): boolean {
8865 if(!isWasmInitialized) {
8866 throw new Error("initializeWasm() must be awaited first!");
8868 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
8869 return nativeResponseValue;
8871 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
8873 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
8874 if(!isWasmInitialized) {
8875 throw new Error("initializeWasm() must be awaited first!");
8877 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
8878 // debug statements here
8880 // uintptr_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
8882 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: number): number {
8883 if(!isWasmInitialized) {
8884 throw new Error("initializeWasm() must be awaited first!");
8886 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
8887 return nativeResponseValue;
8889 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
8891 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
8892 if(!isWasmInitialized) {
8893 throw new Error("initializeWasm() must be awaited first!");
8895 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
8896 return nativeResponseValue;
8898 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
8900 export function CVec_MonitorEventZ_free(_res: number): void {
8901 if(!isWasmInitialized) {
8902 throw new Error("initializeWasm() must be awaited first!");
8904 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
8905 // debug statements here
8907 // uintptr_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg);
8909 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg: number): number {
8910 if(!isWasmInitialized) {
8911 throw new Error("initializeWasm() must be awaited first!");
8913 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg);
8914 return nativeResponseValue;
8916 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(const struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR orig);
8918 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig: number): number {
8919 if(!isWasmInitialized) {
8920 throw new Error("initializeWasm() must be awaited first!");
8922 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig);
8923 return nativeResponseValue;
8925 // struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b, struct LDKPublicKey c);
8927 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a: number, b: number, c: number): number {
8928 if(!isWasmInitialized) {
8929 throw new Error("initializeWasm() must be awaited first!");
8931 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a, b, c);
8932 return nativeResponseValue;
8934 // void C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(struct LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res);
8936 export function C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res: number): void {
8937 if(!isWasmInitialized) {
8938 throw new Error("initializeWasm() must be awaited first!");
8940 const nativeResponseValue = wasm.TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res);
8941 // debug statements here
8943 // void CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(struct LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res);
8945 export function CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res: number): void {
8946 if(!isWasmInitialized) {
8947 throw new Error("initializeWasm() must be awaited first!");
8949 const nativeResponseValue = wasm.TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res);
8950 // debug statements here
8952 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
8954 export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
8955 if(!isWasmInitialized) {
8956 throw new Error("initializeWasm() must be awaited first!");
8958 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_some(o);
8959 return nativeResponseValue;
8961 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
8963 export function COption_C2Tuple_usizeTransactionZZ_none(): number {
8964 if(!isWasmInitialized) {
8965 throw new Error("initializeWasm() must be awaited first!");
8967 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_none();
8968 return nativeResponseValue;
8970 // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
8972 export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8973 if(!isWasmInitialized) {
8974 throw new Error("initializeWasm() must be awaited first!");
8976 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_free(_res);
8977 // debug statements here
8979 // uintptr_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
8981 export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: number): number {
8982 if(!isWasmInitialized) {
8983 throw new Error("initializeWasm() must be awaited first!");
8985 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
8986 return nativeResponseValue;
8988 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
8990 export function COption_C2Tuple_usizeTransactionZZ_clone(orig: number): number {
8991 if(!isWasmInitialized) {
8992 throw new Error("initializeWasm() must be awaited first!");
8994 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone(orig);
8995 return nativeResponseValue;
8997 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
8999 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: number): number {
9000 if(!isWasmInitialized) {
9001 throw new Error("initializeWasm() must be awaited first!");
9003 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
9004 return nativeResponseValue;
9006 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
9008 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: number): number {
9009 if(!isWasmInitialized) {
9010 throw new Error("initializeWasm() must be awaited first!");
9012 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
9013 return nativeResponseValue;
9015 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
9017 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: number): boolean {
9018 if(!isWasmInitialized) {
9019 throw new Error("initializeWasm() must be awaited first!");
9021 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
9022 return nativeResponseValue;
9024 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
9026 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: number): void {
9027 if(!isWasmInitialized) {
9028 throw new Error("initializeWasm() must be awaited first!");
9030 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
9031 // debug statements here
9033 // uintptr_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
9035 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: number): number {
9036 if(!isWasmInitialized) {
9037 throw new Error("initializeWasm() must be awaited first!");
9039 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
9040 return nativeResponseValue;
9042 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
9044 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: number): number {
9045 if(!isWasmInitialized) {
9046 throw new Error("initializeWasm() must be awaited first!");
9048 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
9049 return nativeResponseValue;
9051 // uintptr_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
9053 export function C2Tuple_u64u64Z_clone_ptr(arg: number): number {
9054 if(!isWasmInitialized) {
9055 throw new Error("initializeWasm() must be awaited first!");
9057 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
9058 return nativeResponseValue;
9060 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
9062 export function C2Tuple_u64u64Z_clone(orig: number): number {
9063 if(!isWasmInitialized) {
9064 throw new Error("initializeWasm() must be awaited first!");
9066 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
9067 return nativeResponseValue;
9069 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
9071 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): number {
9072 if(!isWasmInitialized) {
9073 throw new Error("initializeWasm() must be awaited first!");
9075 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
9076 return nativeResponseValue;
9078 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
9080 export function C2Tuple_u64u64Z_free(_res: number): void {
9081 if(!isWasmInitialized) {
9082 throw new Error("initializeWasm() must be awaited first!");
9084 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
9085 // debug statements here
9087 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
9089 export function COption_C2Tuple_u64u64ZZ_some(o: number): number {
9090 if(!isWasmInitialized) {
9091 throw new Error("initializeWasm() must be awaited first!");
9093 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
9094 return nativeResponseValue;
9096 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
9098 export function COption_C2Tuple_u64u64ZZ_none(): number {
9099 if(!isWasmInitialized) {
9100 throw new Error("initializeWasm() must be awaited first!");
9102 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
9103 return nativeResponseValue;
9105 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
9107 export function COption_C2Tuple_u64u64ZZ_free(_res: number): void {
9108 if(!isWasmInitialized) {
9109 throw new Error("initializeWasm() must be awaited first!");
9111 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
9112 // debug statements here
9114 // uintptr_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
9116 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: number): number {
9117 if(!isWasmInitialized) {
9118 throw new Error("initializeWasm() must be awaited first!");
9120 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
9121 return nativeResponseValue;
9123 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
9125 export function COption_C2Tuple_u64u64ZZ_clone(orig: number): number {
9126 if(!isWasmInitialized) {
9127 throw new Error("initializeWasm() must be awaited first!");
9129 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
9130 return nativeResponseValue;
9132 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
9134 export function CVec_NodeIdZ_free(_res: number): void {
9135 if(!isWasmInitialized) {
9136 throw new Error("initializeWasm() must be awaited first!");
9138 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
9139 // debug statements here
9141 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
9143 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: number): number {
9144 if(!isWasmInitialized) {
9145 throw new Error("initializeWasm() must be awaited first!");
9147 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
9148 return nativeResponseValue;
9150 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
9152 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: number): number {
9153 if(!isWasmInitialized) {
9154 throw new Error("initializeWasm() must be awaited first!");
9156 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
9157 return nativeResponseValue;
9159 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
9161 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: number): boolean {
9162 if(!isWasmInitialized) {
9163 throw new Error("initializeWasm() must be awaited first!");
9165 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
9166 return nativeResponseValue;
9168 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
9170 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: number): void {
9171 if(!isWasmInitialized) {
9172 throw new Error("initializeWasm() must be awaited first!");
9174 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
9175 // debug statements here
9177 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
9179 export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
9180 if(!isWasmInitialized) {
9181 throw new Error("initializeWasm() must be awaited first!");
9183 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
9184 return nativeResponseValue;
9186 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9188 export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
9189 if(!isWasmInitialized) {
9190 throw new Error("initializeWasm() must be awaited first!");
9192 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
9193 return nativeResponseValue;
9195 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
9197 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9198 if(!isWasmInitialized) {
9199 throw new Error("initializeWasm() must be awaited first!");
9201 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
9202 return nativeResponseValue;
9204 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
9206 export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
9207 if(!isWasmInitialized) {
9208 throw new Error("initializeWasm() must be awaited first!");
9210 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
9211 // debug statements here
9213 // uintptr_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
9215 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9216 if(!isWasmInitialized) {
9217 throw new Error("initializeWasm() must be awaited first!");
9219 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
9220 return nativeResponseValue;
9222 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
9224 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: number): number {
9225 if(!isWasmInitialized) {
9226 throw new Error("initializeWasm() must be awaited first!");
9228 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
9229 return nativeResponseValue;
9231 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
9233 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
9234 if(!isWasmInitialized) {
9235 throw new Error("initializeWasm() must be awaited first!");
9237 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
9238 return nativeResponseValue;
9240 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9242 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
9243 if(!isWasmInitialized) {
9244 throw new Error("initializeWasm() must be awaited first!");
9246 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
9247 return nativeResponseValue;
9249 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
9251 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9252 if(!isWasmInitialized) {
9253 throw new Error("initializeWasm() must be awaited first!");
9255 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
9256 return nativeResponseValue;
9258 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
9260 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
9261 if(!isWasmInitialized) {
9262 throw new Error("initializeWasm() must be awaited first!");
9264 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
9265 // debug statements here
9267 // uintptr_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
9269 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9270 if(!isWasmInitialized) {
9271 throw new Error("initializeWasm() must be awaited first!");
9273 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
9274 return nativeResponseValue;
9276 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
9278 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: number): number {
9279 if(!isWasmInitialized) {
9280 throw new Error("initializeWasm() must be awaited first!");
9282 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
9283 return nativeResponseValue;
9285 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
9287 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
9288 if(!isWasmInitialized) {
9289 throw new Error("initializeWasm() must be awaited first!");
9291 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
9292 return nativeResponseValue;
9294 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9296 export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
9297 if(!isWasmInitialized) {
9298 throw new Error("initializeWasm() must be awaited first!");
9300 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
9301 return nativeResponseValue;
9303 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
9305 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9306 if(!isWasmInitialized) {
9307 throw new Error("initializeWasm() must be awaited first!");
9309 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
9310 return nativeResponseValue;
9312 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
9314 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
9315 if(!isWasmInitialized) {
9316 throw new Error("initializeWasm() must be awaited first!");
9318 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
9319 // debug statements here
9321 // uintptr_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
9323 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9324 if(!isWasmInitialized) {
9325 throw new Error("initializeWasm() must be awaited first!");
9327 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
9328 return nativeResponseValue;
9330 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
9332 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: number): number {
9333 if(!isWasmInitialized) {
9334 throw new Error("initializeWasm() must be awaited first!");
9336 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
9337 return nativeResponseValue;
9339 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
9341 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
9342 if(!isWasmInitialized) {
9343 throw new Error("initializeWasm() must be awaited first!");
9345 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
9346 return nativeResponseValue;
9348 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9350 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
9351 if(!isWasmInitialized) {
9352 throw new Error("initializeWasm() must be awaited first!");
9354 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
9355 return nativeResponseValue;
9357 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
9359 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9360 if(!isWasmInitialized) {
9361 throw new Error("initializeWasm() must be awaited first!");
9363 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
9364 return nativeResponseValue;
9366 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
9368 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
9369 if(!isWasmInitialized) {
9370 throw new Error("initializeWasm() must be awaited first!");
9372 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
9373 // debug statements here
9375 // uintptr_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
9377 export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9378 if(!isWasmInitialized) {
9379 throw new Error("initializeWasm() must be awaited first!");
9381 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
9382 return nativeResponseValue;
9384 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
9386 export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: number): number {
9387 if(!isWasmInitialized) {
9388 throw new Error("initializeWasm() must be awaited first!");
9390 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
9391 return nativeResponseValue;
9393 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
9395 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: number): number {
9396 if(!isWasmInitialized) {
9397 throw new Error("initializeWasm() must be awaited first!");
9399 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
9400 return nativeResponseValue;
9402 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9404 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: number): number {
9405 if(!isWasmInitialized) {
9406 throw new Error("initializeWasm() must be awaited first!");
9408 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
9409 return nativeResponseValue;
9411 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
9413 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9414 if(!isWasmInitialized) {
9415 throw new Error("initializeWasm() must be awaited first!");
9417 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
9418 return nativeResponseValue;
9420 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
9422 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: number): void {
9423 if(!isWasmInitialized) {
9424 throw new Error("initializeWasm() must be awaited first!");
9426 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
9427 // debug statements here
9429 // uintptr_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
9431 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9432 if(!isWasmInitialized) {
9433 throw new Error("initializeWasm() must be awaited first!");
9435 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
9436 return nativeResponseValue;
9438 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
9440 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: number): number {
9441 if(!isWasmInitialized) {
9442 throw new Error("initializeWasm() must be awaited first!");
9444 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
9445 return nativeResponseValue;
9447 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
9449 export function CResult_NodeIdDecodeErrorZ_ok(o: number): number {
9450 if(!isWasmInitialized) {
9451 throw new Error("initializeWasm() must be awaited first!");
9453 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
9454 return nativeResponseValue;
9456 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
9458 export function CResult_NodeIdDecodeErrorZ_err(e: number): number {
9459 if(!isWasmInitialized) {
9460 throw new Error("initializeWasm() must be awaited first!");
9462 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
9463 return nativeResponseValue;
9465 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
9467 export function CResult_NodeIdDecodeErrorZ_is_ok(o: number): boolean {
9468 if(!isWasmInitialized) {
9469 throw new Error("initializeWasm() must be awaited first!");
9471 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
9472 return nativeResponseValue;
9474 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
9476 export function CResult_NodeIdDecodeErrorZ_free(_res: number): void {
9477 if(!isWasmInitialized) {
9478 throw new Error("initializeWasm() must be awaited first!");
9480 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
9481 // debug statements here
9483 // uintptr_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
9485 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: number): number {
9486 if(!isWasmInitialized) {
9487 throw new Error("initializeWasm() must be awaited first!");
9489 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
9490 return nativeResponseValue;
9492 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
9494 export function CResult_NodeIdDecodeErrorZ_clone(orig: number): number {
9495 if(!isWasmInitialized) {
9496 throw new Error("initializeWasm() must be awaited first!");
9498 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
9499 return nativeResponseValue;
9501 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
9503 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: number): number {
9504 if(!isWasmInitialized) {
9505 throw new Error("initializeWasm() must be awaited first!");
9507 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
9508 return nativeResponseValue;
9510 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
9512 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: number): number {
9513 if(!isWasmInitialized) {
9514 throw new Error("initializeWasm() must be awaited first!");
9516 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
9517 return nativeResponseValue;
9519 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
9521 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: number): boolean {
9522 if(!isWasmInitialized) {
9523 throw new Error("initializeWasm() must be awaited first!");
9525 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
9526 return nativeResponseValue;
9528 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
9530 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: number): void {
9531 if(!isWasmInitialized) {
9532 throw new Error("initializeWasm() must be awaited first!");
9534 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
9535 // debug statements here
9537 // uintptr_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
9539 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: number): number {
9540 if(!isWasmInitialized) {
9541 throw new Error("initializeWasm() must be awaited first!");
9543 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
9544 return nativeResponseValue;
9546 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
9548 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: number): number {
9549 if(!isWasmInitialized) {
9550 throw new Error("initializeWasm() must be awaited first!");
9552 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
9553 return nativeResponseValue;
9555 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
9557 export function COption_AccessZ_some(o: number): number {
9558 if(!isWasmInitialized) {
9559 throw new Error("initializeWasm() must be awaited first!");
9561 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
9562 return nativeResponseValue;
9564 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
9566 export function COption_AccessZ_none(): number {
9567 if(!isWasmInitialized) {
9568 throw new Error("initializeWasm() must be awaited first!");
9570 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
9571 return nativeResponseValue;
9573 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
9575 export function COption_AccessZ_free(_res: number): void {
9576 if(!isWasmInitialized) {
9577 throw new Error("initializeWasm() must be awaited first!");
9579 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
9580 // debug statements here
9582 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
9584 export function CResult_boolLightningErrorZ_ok(o: boolean): number {
9585 if(!isWasmInitialized) {
9586 throw new Error("initializeWasm() must be awaited first!");
9588 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
9589 return nativeResponseValue;
9591 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
9593 export function CResult_boolLightningErrorZ_err(e: number): number {
9594 if(!isWasmInitialized) {
9595 throw new Error("initializeWasm() must be awaited first!");
9597 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
9598 return nativeResponseValue;
9600 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
9602 export function CResult_boolLightningErrorZ_is_ok(o: number): boolean {
9603 if(!isWasmInitialized) {
9604 throw new Error("initializeWasm() must be awaited first!");
9606 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
9607 return nativeResponseValue;
9609 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
9611 export function CResult_boolLightningErrorZ_free(_res: number): void {
9612 if(!isWasmInitialized) {
9613 throw new Error("initializeWasm() must be awaited first!");
9615 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
9616 // debug statements here
9618 // uintptr_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
9620 export function CResult_boolLightningErrorZ_clone_ptr(arg: number): number {
9621 if(!isWasmInitialized) {
9622 throw new Error("initializeWasm() must be awaited first!");
9624 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
9625 return nativeResponseValue;
9627 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
9629 export function CResult_boolLightningErrorZ_clone(orig: number): number {
9630 if(!isWasmInitialized) {
9631 throw new Error("initializeWasm() must be awaited first!");
9633 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
9634 return nativeResponseValue;
9636 // uintptr_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
9638 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: number): number {
9639 if(!isWasmInitialized) {
9640 throw new Error("initializeWasm() must be awaited first!");
9642 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
9643 return nativeResponseValue;
9645 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
9647 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
9648 if(!isWasmInitialized) {
9649 throw new Error("initializeWasm() must be awaited first!");
9651 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
9652 return nativeResponseValue;
9654 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
9656 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
9657 if(!isWasmInitialized) {
9658 throw new Error("initializeWasm() must be awaited first!");
9660 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
9661 return nativeResponseValue;
9663 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
9665 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
9666 if(!isWasmInitialized) {
9667 throw new Error("initializeWasm() must be awaited first!");
9669 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
9670 // debug statements here
9672 // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
9674 export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number): void {
9675 if(!isWasmInitialized) {
9676 throw new Error("initializeWasm() must be awaited first!");
9678 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
9679 // debug statements here
9681 // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
9683 export function CVec_NodeAnnouncementZ_free(_res: number): void {
9684 if(!isWasmInitialized) {
9685 throw new Error("initializeWasm() must be awaited first!");
9687 const nativeResponseValue = wasm.TS_CVec_NodeAnnouncementZ_free(_res);
9688 // debug statements here
9690 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
9692 export function CResult_NoneLightningErrorZ_ok(): number {
9693 if(!isWasmInitialized) {
9694 throw new Error("initializeWasm() must be awaited first!");
9696 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
9697 return nativeResponseValue;
9699 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
9701 export function CResult_NoneLightningErrorZ_err(e: number): number {
9702 if(!isWasmInitialized) {
9703 throw new Error("initializeWasm() must be awaited first!");
9705 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
9706 return nativeResponseValue;
9708 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
9710 export function CResult_NoneLightningErrorZ_is_ok(o: number): boolean {
9711 if(!isWasmInitialized) {
9712 throw new Error("initializeWasm() must be awaited first!");
9714 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
9715 return nativeResponseValue;
9717 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
9719 export function CResult_NoneLightningErrorZ_free(_res: number): void {
9720 if(!isWasmInitialized) {
9721 throw new Error("initializeWasm() must be awaited first!");
9723 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
9724 // debug statements here
9726 // uintptr_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
9728 export function CResult_NoneLightningErrorZ_clone_ptr(arg: number): number {
9729 if(!isWasmInitialized) {
9730 throw new Error("initializeWasm() must be awaited first!");
9732 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
9733 return nativeResponseValue;
9735 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
9737 export function CResult_NoneLightningErrorZ_clone(orig: number): number {
9738 if(!isWasmInitialized) {
9739 throw new Error("initializeWasm() must be awaited first!");
9741 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
9742 return nativeResponseValue;
9744 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
9746 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: number): number {
9747 if(!isWasmInitialized) {
9748 throw new Error("initializeWasm() must be awaited first!");
9750 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
9751 return nativeResponseValue;
9753 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
9755 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: number): number {
9756 if(!isWasmInitialized) {
9757 throw new Error("initializeWasm() must be awaited first!");
9759 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
9760 return nativeResponseValue;
9762 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
9764 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: number): boolean {
9765 if(!isWasmInitialized) {
9766 throw new Error("initializeWasm() must be awaited first!");
9768 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
9769 return nativeResponseValue;
9771 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
9773 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: number): void {
9774 if(!isWasmInitialized) {
9775 throw new Error("initializeWasm() must be awaited first!");
9777 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
9778 // debug statements here
9780 // uintptr_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
9782 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: number): number {
9783 if(!isWasmInitialized) {
9784 throw new Error("initializeWasm() must be awaited first!");
9786 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
9787 return nativeResponseValue;
9789 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
9791 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: number): number {
9792 if(!isWasmInitialized) {
9793 throw new Error("initializeWasm() must be awaited first!");
9795 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
9796 return nativeResponseValue;
9798 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
9800 export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
9801 if(!isWasmInitialized) {
9802 throw new Error("initializeWasm() must be awaited first!");
9804 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
9805 return nativeResponseValue;
9807 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
9809 export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
9810 if(!isWasmInitialized) {
9811 throw new Error("initializeWasm() must be awaited first!");
9813 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
9814 return nativeResponseValue;
9816 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
9818 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
9819 if(!isWasmInitialized) {
9820 throw new Error("initializeWasm() must be awaited first!");
9822 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
9823 return nativeResponseValue;
9825 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
9827 export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
9828 if(!isWasmInitialized) {
9829 throw new Error("initializeWasm() must be awaited first!");
9831 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
9832 // debug statements here
9834 // uintptr_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
9836 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
9837 if(!isWasmInitialized) {
9838 throw new Error("initializeWasm() must be awaited first!");
9840 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
9841 return nativeResponseValue;
9843 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
9845 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
9846 if(!isWasmInitialized) {
9847 throw new Error("initializeWasm() must be awaited first!");
9849 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
9850 return nativeResponseValue;
9852 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
9854 export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
9855 if(!isWasmInitialized) {
9856 throw new Error("initializeWasm() must be awaited first!");
9858 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
9859 return nativeResponseValue;
9861 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
9863 export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
9864 if(!isWasmInitialized) {
9865 throw new Error("initializeWasm() must be awaited first!");
9867 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
9868 return nativeResponseValue;
9870 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
9872 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: number): boolean {
9873 if(!isWasmInitialized) {
9874 throw new Error("initializeWasm() must be awaited first!");
9876 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
9877 return nativeResponseValue;
9879 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
9881 export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
9882 if(!isWasmInitialized) {
9883 throw new Error("initializeWasm() must be awaited first!");
9885 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
9886 // debug statements here
9888 // uintptr_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
9890 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: number): number {
9891 if(!isWasmInitialized) {
9892 throw new Error("initializeWasm() must be awaited first!");
9894 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
9895 return nativeResponseValue;
9897 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
9899 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
9900 if(!isWasmInitialized) {
9901 throw new Error("initializeWasm() must be awaited first!");
9903 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
9904 return nativeResponseValue;
9906 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
9908 export function CVec_NetAddressZ_free(_res: number): void {
9909 if(!isWasmInitialized) {
9910 throw new Error("initializeWasm() must be awaited first!");
9912 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
9913 // debug statements here
9915 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
9917 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
9918 if(!isWasmInitialized) {
9919 throw new Error("initializeWasm() must be awaited first!");
9921 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
9922 return nativeResponseValue;
9924 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
9926 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
9927 if(!isWasmInitialized) {
9928 throw new Error("initializeWasm() must be awaited first!");
9930 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
9931 return nativeResponseValue;
9933 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
9935 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: number): boolean {
9936 if(!isWasmInitialized) {
9937 throw new Error("initializeWasm() must be awaited first!");
9939 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
9940 return nativeResponseValue;
9942 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
9944 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
9945 if(!isWasmInitialized) {
9946 throw new Error("initializeWasm() must be awaited first!");
9948 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
9949 // debug statements here
9951 // uintptr_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
9953 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: number): number {
9954 if(!isWasmInitialized) {
9955 throw new Error("initializeWasm() must be awaited first!");
9957 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
9958 return nativeResponseValue;
9960 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
9962 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
9963 if(!isWasmInitialized) {
9964 throw new Error("initializeWasm() must be awaited first!");
9966 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
9967 return nativeResponseValue;
9969 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
9971 export function CResult_NodeAliasDecodeErrorZ_ok(o: number): number {
9972 if(!isWasmInitialized) {
9973 throw new Error("initializeWasm() must be awaited first!");
9975 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
9976 return nativeResponseValue;
9978 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
9980 export function CResult_NodeAliasDecodeErrorZ_err(e: number): number {
9981 if(!isWasmInitialized) {
9982 throw new Error("initializeWasm() must be awaited first!");
9984 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
9985 return nativeResponseValue;
9987 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
9989 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: number): boolean {
9990 if(!isWasmInitialized) {
9991 throw new Error("initializeWasm() must be awaited first!");
9993 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
9994 return nativeResponseValue;
9996 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
9998 export function CResult_NodeAliasDecodeErrorZ_free(_res: number): void {
9999 if(!isWasmInitialized) {
10000 throw new Error("initializeWasm() must be awaited first!");
10002 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
10003 // debug statements here
10005 // uintptr_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
10007 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: number): number {
10008 if(!isWasmInitialized) {
10009 throw new Error("initializeWasm() must be awaited first!");
10011 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
10012 return nativeResponseValue;
10014 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
10016 export function CResult_NodeAliasDecodeErrorZ_clone(orig: number): number {
10017 if(!isWasmInitialized) {
10018 throw new Error("initializeWasm() must be awaited first!");
10020 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
10021 return nativeResponseValue;
10023 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
10025 export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
10026 if(!isWasmInitialized) {
10027 throw new Error("initializeWasm() must be awaited first!");
10029 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
10030 return nativeResponseValue;
10032 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
10034 export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
10035 if(!isWasmInitialized) {
10036 throw new Error("initializeWasm() must be awaited first!");
10038 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
10039 return nativeResponseValue;
10041 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
10043 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: number): boolean {
10044 if(!isWasmInitialized) {
10045 throw new Error("initializeWasm() must be awaited first!");
10047 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
10048 return nativeResponseValue;
10050 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
10052 export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
10053 if(!isWasmInitialized) {
10054 throw new Error("initializeWasm() must be awaited first!");
10056 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
10057 // debug statements here
10059 // uintptr_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
10061 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: number): number {
10062 if(!isWasmInitialized) {
10063 throw new Error("initializeWasm() must be awaited first!");
10065 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
10066 return nativeResponseValue;
10068 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
10070 export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
10071 if(!isWasmInitialized) {
10072 throw new Error("initializeWasm() must be awaited first!");
10074 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
10075 return nativeResponseValue;
10077 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
10079 export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
10080 if(!isWasmInitialized) {
10081 throw new Error("initializeWasm() must be awaited first!");
10083 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
10084 return nativeResponseValue;
10086 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
10088 export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
10089 if(!isWasmInitialized) {
10090 throw new Error("initializeWasm() must be awaited first!");
10092 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
10093 return nativeResponseValue;
10095 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
10097 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: number): boolean {
10098 if(!isWasmInitialized) {
10099 throw new Error("initializeWasm() must be awaited first!");
10101 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
10102 return nativeResponseValue;
10104 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
10106 export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
10107 if(!isWasmInitialized) {
10108 throw new Error("initializeWasm() must be awaited first!");
10110 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
10111 // debug statements here
10113 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
10115 export function COption_CVec_NetAddressZZ_some(o: number): number {
10116 if(!isWasmInitialized) {
10117 throw new Error("initializeWasm() must be awaited first!");
10119 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
10120 return nativeResponseValue;
10122 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
10124 export function COption_CVec_NetAddressZZ_none(): number {
10125 if(!isWasmInitialized) {
10126 throw new Error("initializeWasm() must be awaited first!");
10128 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
10129 return nativeResponseValue;
10131 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
10133 export function COption_CVec_NetAddressZZ_free(_res: number): void {
10134 if(!isWasmInitialized) {
10135 throw new Error("initializeWasm() must be awaited first!");
10137 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
10138 // debug statements here
10140 // uintptr_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
10142 export function COption_CVec_NetAddressZZ_clone_ptr(arg: number): number {
10143 if(!isWasmInitialized) {
10144 throw new Error("initializeWasm() must be awaited first!");
10146 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
10147 return nativeResponseValue;
10149 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
10151 export function COption_CVec_NetAddressZZ_clone(orig: number): number {
10152 if(!isWasmInitialized) {
10153 throw new Error("initializeWasm() must be awaited first!");
10155 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
10156 return nativeResponseValue;
10158 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
10160 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
10161 if(!isWasmInitialized) {
10162 throw new Error("initializeWasm() must be awaited first!");
10164 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
10165 return nativeResponseValue;
10167 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10169 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
10170 if(!isWasmInitialized) {
10171 throw new Error("initializeWasm() must be awaited first!");
10173 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
10174 return nativeResponseValue;
10176 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10178 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
10179 if(!isWasmInitialized) {
10180 throw new Error("initializeWasm() must be awaited first!");
10182 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10183 return nativeResponseValue;
10185 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
10187 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
10188 if(!isWasmInitialized) {
10189 throw new Error("initializeWasm() must be awaited first!");
10191 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
10192 // debug statements here
10194 // uintptr_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10196 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10197 if(!isWasmInitialized) {
10198 throw new Error("initializeWasm() must be awaited first!");
10200 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10201 return nativeResponseValue;
10203 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10205 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
10206 if(!isWasmInitialized) {
10207 throw new Error("initializeWasm() must be awaited first!");
10209 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10210 return nativeResponseValue;
10212 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
10214 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
10215 if(!isWasmInitialized) {
10216 throw new Error("initializeWasm() must be awaited first!");
10218 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
10219 return nativeResponseValue;
10221 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10223 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
10224 if(!isWasmInitialized) {
10225 throw new Error("initializeWasm() must be awaited first!");
10227 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
10228 return nativeResponseValue;
10230 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10232 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
10233 if(!isWasmInitialized) {
10234 throw new Error("initializeWasm() must be awaited first!");
10236 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
10237 return nativeResponseValue;
10239 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
10241 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
10242 if(!isWasmInitialized) {
10243 throw new Error("initializeWasm() must be awaited first!");
10245 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
10246 // debug statements here
10248 // uintptr_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10250 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10251 if(!isWasmInitialized) {
10252 throw new Error("initializeWasm() must be awaited first!");
10254 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10255 return nativeResponseValue;
10257 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10259 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
10260 if(!isWasmInitialized) {
10261 throw new Error("initializeWasm() must be awaited first!");
10263 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
10264 return nativeResponseValue;
10266 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
10268 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
10269 if(!isWasmInitialized) {
10270 throw new Error("initializeWasm() must be awaited first!");
10272 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
10273 return nativeResponseValue;
10275 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
10277 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
10278 if(!isWasmInitialized) {
10279 throw new Error("initializeWasm() must be awaited first!");
10281 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
10282 return nativeResponseValue;
10284 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
10286 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
10287 if(!isWasmInitialized) {
10288 throw new Error("initializeWasm() must be awaited first!");
10290 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
10291 return nativeResponseValue;
10293 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
10295 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
10296 if(!isWasmInitialized) {
10297 throw new Error("initializeWasm() must be awaited first!");
10299 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
10300 // debug statements here
10302 // uintptr_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
10304 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
10305 if(!isWasmInitialized) {
10306 throw new Error("initializeWasm() must be awaited first!");
10308 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
10309 return nativeResponseValue;
10311 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
10313 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
10314 if(!isWasmInitialized) {
10315 throw new Error("initializeWasm() must be awaited first!");
10317 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
10318 return nativeResponseValue;
10320 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
10322 export function CVec_PaymentPreimageZ_free(_res: number): void {
10323 if(!isWasmInitialized) {
10324 throw new Error("initializeWasm() must be awaited first!");
10326 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
10327 // debug statements here
10329 // uintptr_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
10331 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: number): number {
10332 if(!isWasmInitialized) {
10333 throw new Error("initializeWasm() must be awaited first!");
10335 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
10336 return nativeResponseValue;
10338 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
10340 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
10341 if(!isWasmInitialized) {
10342 throw new Error("initializeWasm() must be awaited first!");
10344 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
10345 return nativeResponseValue;
10347 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
10349 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): number {
10350 if(!isWasmInitialized) {
10351 throw new Error("initializeWasm() must be awaited first!");
10353 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
10354 return nativeResponseValue;
10356 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
10358 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
10359 if(!isWasmInitialized) {
10360 throw new Error("initializeWasm() must be awaited first!");
10362 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
10363 // debug statements here
10365 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
10367 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
10368 if(!isWasmInitialized) {
10369 throw new Error("initializeWasm() must be awaited first!");
10371 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
10372 return nativeResponseValue;
10374 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
10376 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
10377 if(!isWasmInitialized) {
10378 throw new Error("initializeWasm() must be awaited first!");
10380 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
10381 return nativeResponseValue;
10383 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
10385 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: number): boolean {
10386 if(!isWasmInitialized) {
10387 throw new Error("initializeWasm() must be awaited first!");
10389 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
10390 return nativeResponseValue;
10392 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
10394 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
10395 if(!isWasmInitialized) {
10396 throw new Error("initializeWasm() must be awaited first!");
10398 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
10399 // debug statements here
10401 // uintptr_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
10403 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: number): number {
10404 if(!isWasmInitialized) {
10405 throw new Error("initializeWasm() must be awaited first!");
10407 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
10408 return nativeResponseValue;
10410 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
10412 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
10413 if(!isWasmInitialized) {
10414 throw new Error("initializeWasm() must be awaited first!");
10416 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
10417 return nativeResponseValue;
10419 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
10421 export function CResult_SignatureNoneZ_ok(o: number): number {
10422 if(!isWasmInitialized) {
10423 throw new Error("initializeWasm() must be awaited first!");
10425 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
10426 return nativeResponseValue;
10428 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
10430 export function CResult_SignatureNoneZ_err(): number {
10431 if(!isWasmInitialized) {
10432 throw new Error("initializeWasm() must be awaited first!");
10434 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
10435 return nativeResponseValue;
10437 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
10439 export function CResult_SignatureNoneZ_is_ok(o: number): boolean {
10440 if(!isWasmInitialized) {
10441 throw new Error("initializeWasm() must be awaited first!");
10443 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
10444 return nativeResponseValue;
10446 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
10448 export function CResult_SignatureNoneZ_free(_res: number): void {
10449 if(!isWasmInitialized) {
10450 throw new Error("initializeWasm() must be awaited first!");
10452 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
10453 // debug statements here
10455 // uintptr_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
10457 export function CResult_SignatureNoneZ_clone_ptr(arg: number): number {
10458 if(!isWasmInitialized) {
10459 throw new Error("initializeWasm() must be awaited first!");
10461 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
10462 return nativeResponseValue;
10464 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
10466 export function CResult_SignatureNoneZ_clone(orig: number): number {
10467 if(!isWasmInitialized) {
10468 throw new Error("initializeWasm() must be awaited first!");
10470 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
10471 return nativeResponseValue;
10473 // uintptr_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
10475 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: number): number {
10476 if(!isWasmInitialized) {
10477 throw new Error("initializeWasm() must be awaited first!");
10479 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
10480 return nativeResponseValue;
10482 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
10484 export function C2Tuple_SignatureSignatureZ_clone(orig: number): number {
10485 if(!isWasmInitialized) {
10486 throw new Error("initializeWasm() must be awaited first!");
10488 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
10489 return nativeResponseValue;
10491 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
10493 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): number {
10494 if(!isWasmInitialized) {
10495 throw new Error("initializeWasm() must be awaited first!");
10497 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
10498 return nativeResponseValue;
10500 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
10502 export function C2Tuple_SignatureSignatureZ_free(_res: number): void {
10503 if(!isWasmInitialized) {
10504 throw new Error("initializeWasm() must be awaited first!");
10506 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
10507 // debug statements here
10509 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
10511 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: number): number {
10512 if(!isWasmInitialized) {
10513 throw new Error("initializeWasm() must be awaited first!");
10515 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
10516 return nativeResponseValue;
10518 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
10520 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): number {
10521 if(!isWasmInitialized) {
10522 throw new Error("initializeWasm() must be awaited first!");
10524 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
10525 return nativeResponseValue;
10527 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
10529 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: number): boolean {
10530 if(!isWasmInitialized) {
10531 throw new Error("initializeWasm() must be awaited first!");
10533 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
10534 return nativeResponseValue;
10536 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
10538 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: number): void {
10539 if(!isWasmInitialized) {
10540 throw new Error("initializeWasm() must be awaited first!");
10542 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
10543 // debug statements here
10545 // uintptr_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
10547 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: number): number {
10548 if(!isWasmInitialized) {
10549 throw new Error("initializeWasm() must be awaited first!");
10551 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
10552 return nativeResponseValue;
10554 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
10556 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: number): number {
10557 if(!isWasmInitialized) {
10558 throw new Error("initializeWasm() must be awaited first!");
10560 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
10561 return nativeResponseValue;
10563 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
10565 export function CResult_SecretKeyNoneZ_ok(o: number): number {
10566 if(!isWasmInitialized) {
10567 throw new Error("initializeWasm() must be awaited first!");
10569 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
10570 return nativeResponseValue;
10572 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
10574 export function CResult_SecretKeyNoneZ_err(): number {
10575 if(!isWasmInitialized) {
10576 throw new Error("initializeWasm() must be awaited first!");
10578 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
10579 return nativeResponseValue;
10581 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
10583 export function CResult_SecretKeyNoneZ_is_ok(o: number): boolean {
10584 if(!isWasmInitialized) {
10585 throw new Error("initializeWasm() must be awaited first!");
10587 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
10588 return nativeResponseValue;
10590 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
10592 export function CResult_SecretKeyNoneZ_free(_res: number): void {
10593 if(!isWasmInitialized) {
10594 throw new Error("initializeWasm() must be awaited first!");
10596 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
10597 // debug statements here
10599 // uintptr_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
10601 export function CResult_SecretKeyNoneZ_clone_ptr(arg: number): number {
10602 if(!isWasmInitialized) {
10603 throw new Error("initializeWasm() must be awaited first!");
10605 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
10606 return nativeResponseValue;
10608 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
10610 export function CResult_SecretKeyNoneZ_clone(orig: number): number {
10611 if(!isWasmInitialized) {
10612 throw new Error("initializeWasm() must be awaited first!");
10614 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
10615 return nativeResponseValue;
10617 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
10619 export function CResult_SignDecodeErrorZ_ok(o: number): number {
10620 if(!isWasmInitialized) {
10621 throw new Error("initializeWasm() must be awaited first!");
10623 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
10624 return nativeResponseValue;
10626 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
10628 export function CResult_SignDecodeErrorZ_err(e: number): number {
10629 if(!isWasmInitialized) {
10630 throw new Error("initializeWasm() must be awaited first!");
10632 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
10633 return nativeResponseValue;
10635 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
10637 export function CResult_SignDecodeErrorZ_is_ok(o: number): boolean {
10638 if(!isWasmInitialized) {
10639 throw new Error("initializeWasm() must be awaited first!");
10641 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
10642 return nativeResponseValue;
10644 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
10646 export function CResult_SignDecodeErrorZ_free(_res: number): void {
10647 if(!isWasmInitialized) {
10648 throw new Error("initializeWasm() must be awaited first!");
10650 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
10651 // debug statements here
10653 // uintptr_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
10655 export function CResult_SignDecodeErrorZ_clone_ptr(arg: number): number {
10656 if(!isWasmInitialized) {
10657 throw new Error("initializeWasm() must be awaited first!");
10659 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
10660 return nativeResponseValue;
10662 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
10664 export function CResult_SignDecodeErrorZ_clone(orig: number): number {
10665 if(!isWasmInitialized) {
10666 throw new Error("initializeWasm() must be awaited first!");
10668 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
10669 return nativeResponseValue;
10671 // void CVec_u5Z_free(struct LDKCVec_u5Z _res);
10673 export function CVec_u5Z_free(_res: number): void {
10674 if(!isWasmInitialized) {
10675 throw new Error("initializeWasm() must be awaited first!");
10677 const nativeResponseValue = wasm.TS_CVec_u5Z_free(_res);
10678 // debug statements here
10680 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
10682 export function CResult_RecoverableSignatureNoneZ_ok(o: number): number {
10683 if(!isWasmInitialized) {
10684 throw new Error("initializeWasm() must be awaited first!");
10686 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
10687 return nativeResponseValue;
10689 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
10691 export function CResult_RecoverableSignatureNoneZ_err(): number {
10692 if(!isWasmInitialized) {
10693 throw new Error("initializeWasm() must be awaited first!");
10695 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
10696 return nativeResponseValue;
10698 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
10700 export function CResult_RecoverableSignatureNoneZ_is_ok(o: number): boolean {
10701 if(!isWasmInitialized) {
10702 throw new Error("initializeWasm() must be awaited first!");
10704 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
10705 return nativeResponseValue;
10707 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
10709 export function CResult_RecoverableSignatureNoneZ_free(_res: number): void {
10710 if(!isWasmInitialized) {
10711 throw new Error("initializeWasm() must be awaited first!");
10713 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
10714 // debug statements here
10716 // uintptr_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
10718 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: number): number {
10719 if(!isWasmInitialized) {
10720 throw new Error("initializeWasm() must be awaited first!");
10722 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
10723 return nativeResponseValue;
10725 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
10727 export function CResult_RecoverableSignatureNoneZ_clone(orig: number): number {
10728 if(!isWasmInitialized) {
10729 throw new Error("initializeWasm() must be awaited first!");
10731 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
10732 return nativeResponseValue;
10734 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
10736 export function CVec_u8Z_free(_res: number): void {
10737 if(!isWasmInitialized) {
10738 throw new Error("initializeWasm() must be awaited first!");
10740 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
10741 // debug statements here
10743 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
10745 export function CVec_CVec_u8ZZ_free(_res: number): void {
10746 if(!isWasmInitialized) {
10747 throw new Error("initializeWasm() must be awaited first!");
10749 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
10750 // debug statements here
10752 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
10754 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): number {
10755 if(!isWasmInitialized) {
10756 throw new Error("initializeWasm() must be awaited first!");
10758 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
10759 return nativeResponseValue;
10761 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
10763 export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
10764 if(!isWasmInitialized) {
10765 throw new Error("initializeWasm() must be awaited first!");
10767 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
10768 return nativeResponseValue;
10770 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
10772 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: number): boolean {
10773 if(!isWasmInitialized) {
10774 throw new Error("initializeWasm() must be awaited first!");
10776 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
10777 return nativeResponseValue;
10779 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
10781 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
10782 if(!isWasmInitialized) {
10783 throw new Error("initializeWasm() must be awaited first!");
10785 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
10786 // debug statements here
10788 // uintptr_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
10790 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: number): number {
10791 if(!isWasmInitialized) {
10792 throw new Error("initializeWasm() must be awaited first!");
10794 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
10795 return nativeResponseValue;
10797 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
10799 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
10800 if(!isWasmInitialized) {
10801 throw new Error("initializeWasm() must be awaited first!");
10803 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
10804 return nativeResponseValue;
10806 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
10808 export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
10809 if(!isWasmInitialized) {
10810 throw new Error("initializeWasm() must be awaited first!");
10812 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
10813 return nativeResponseValue;
10815 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
10817 export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
10818 if(!isWasmInitialized) {
10819 throw new Error("initializeWasm() must be awaited first!");
10821 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
10822 return nativeResponseValue;
10824 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
10826 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: number): boolean {
10827 if(!isWasmInitialized) {
10828 throw new Error("initializeWasm() must be awaited first!");
10830 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
10831 return nativeResponseValue;
10833 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
10835 export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
10836 if(!isWasmInitialized) {
10837 throw new Error("initializeWasm() must be awaited first!");
10839 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
10840 // debug statements here
10842 // uintptr_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
10844 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: number): number {
10845 if(!isWasmInitialized) {
10846 throw new Error("initializeWasm() must be awaited first!");
10848 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
10849 return nativeResponseValue;
10851 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
10853 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
10854 if(!isWasmInitialized) {
10855 throw new Error("initializeWasm() must be awaited first!");
10857 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
10858 return nativeResponseValue;
10860 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
10862 export function CVec_TxOutZ_free(_res: number): void {
10863 if(!isWasmInitialized) {
10864 throw new Error("initializeWasm() must be awaited first!");
10866 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
10867 // debug statements here
10869 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
10871 export function CResult_TransactionNoneZ_ok(o: number): number {
10872 if(!isWasmInitialized) {
10873 throw new Error("initializeWasm() must be awaited first!");
10875 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
10876 return nativeResponseValue;
10878 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
10880 export function CResult_TransactionNoneZ_err(): number {
10881 if(!isWasmInitialized) {
10882 throw new Error("initializeWasm() must be awaited first!");
10884 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
10885 return nativeResponseValue;
10887 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
10889 export function CResult_TransactionNoneZ_is_ok(o: number): boolean {
10890 if(!isWasmInitialized) {
10891 throw new Error("initializeWasm() must be awaited first!");
10893 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
10894 return nativeResponseValue;
10896 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
10898 export function CResult_TransactionNoneZ_free(_res: number): void {
10899 if(!isWasmInitialized) {
10900 throw new Error("initializeWasm() must be awaited first!");
10902 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
10903 // debug statements here
10905 // uintptr_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
10907 export function CResult_TransactionNoneZ_clone_ptr(arg: number): number {
10908 if(!isWasmInitialized) {
10909 throw new Error("initializeWasm() must be awaited first!");
10911 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
10912 return nativeResponseValue;
10914 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
10916 export function CResult_TransactionNoneZ_clone(orig: number): number {
10917 if(!isWasmInitialized) {
10918 throw new Error("initializeWasm() must be awaited first!");
10920 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
10921 return nativeResponseValue;
10923 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
10925 export function COption_u16Z_some(o: number): number {
10926 if(!isWasmInitialized) {
10927 throw new Error("initializeWasm() must be awaited first!");
10929 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
10930 return nativeResponseValue;
10932 // struct LDKCOption_u16Z COption_u16Z_none(void);
10934 export function COption_u16Z_none(): number {
10935 if(!isWasmInitialized) {
10936 throw new Error("initializeWasm() must be awaited first!");
10938 const nativeResponseValue = wasm.TS_COption_u16Z_none();
10939 return nativeResponseValue;
10941 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
10943 export function COption_u16Z_free(_res: number): void {
10944 if(!isWasmInitialized) {
10945 throw new Error("initializeWasm() must be awaited first!");
10947 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
10948 // debug statements here
10950 // uintptr_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
10952 export function COption_u16Z_clone_ptr(arg: number): number {
10953 if(!isWasmInitialized) {
10954 throw new Error("initializeWasm() must be awaited first!");
10956 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
10957 return nativeResponseValue;
10959 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
10961 export function COption_u16Z_clone(orig: number): number {
10962 if(!isWasmInitialized) {
10963 throw new Error("initializeWasm() must be awaited first!");
10965 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
10966 return nativeResponseValue;
10968 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
10970 export function CResult_NoneAPIErrorZ_ok(): number {
10971 if(!isWasmInitialized) {
10972 throw new Error("initializeWasm() must be awaited first!");
10974 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
10975 return nativeResponseValue;
10977 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
10979 export function CResult_NoneAPIErrorZ_err(e: number): number {
10980 if(!isWasmInitialized) {
10981 throw new Error("initializeWasm() must be awaited first!");
10983 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
10984 return nativeResponseValue;
10986 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
10988 export function CResult_NoneAPIErrorZ_is_ok(o: number): boolean {
10989 if(!isWasmInitialized) {
10990 throw new Error("initializeWasm() must be awaited first!");
10992 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
10993 return nativeResponseValue;
10995 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
10997 export function CResult_NoneAPIErrorZ_free(_res: number): void {
10998 if(!isWasmInitialized) {
10999 throw new Error("initializeWasm() must be awaited first!");
11001 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
11002 // debug statements here
11004 // uintptr_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
11006 export function CResult_NoneAPIErrorZ_clone_ptr(arg: number): number {
11007 if(!isWasmInitialized) {
11008 throw new Error("initializeWasm() must be awaited first!");
11010 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
11011 return nativeResponseValue;
11013 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
11015 export function CResult_NoneAPIErrorZ_clone(orig: number): number {
11016 if(!isWasmInitialized) {
11017 throw new Error("initializeWasm() must be awaited first!");
11019 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
11020 return nativeResponseValue;
11022 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
11024 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
11025 if(!isWasmInitialized) {
11026 throw new Error("initializeWasm() must be awaited first!");
11028 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
11029 // debug statements here
11031 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
11033 export function CVec_APIErrorZ_free(_res: number): void {
11034 if(!isWasmInitialized) {
11035 throw new Error("initializeWasm() must be awaited first!");
11037 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
11038 // debug statements here
11040 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
11042 export function CResult__u832APIErrorZ_ok(o: number): number {
11043 if(!isWasmInitialized) {
11044 throw new Error("initializeWasm() must be awaited first!");
11046 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
11047 return nativeResponseValue;
11049 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
11051 export function CResult__u832APIErrorZ_err(e: number): number {
11052 if(!isWasmInitialized) {
11053 throw new Error("initializeWasm() must be awaited first!");
11055 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
11056 return nativeResponseValue;
11058 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
11060 export function CResult__u832APIErrorZ_is_ok(o: number): boolean {
11061 if(!isWasmInitialized) {
11062 throw new Error("initializeWasm() must be awaited first!");
11064 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
11065 return nativeResponseValue;
11067 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
11069 export function CResult__u832APIErrorZ_free(_res: number): void {
11070 if(!isWasmInitialized) {
11071 throw new Error("initializeWasm() must be awaited first!");
11073 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
11074 // debug statements here
11076 // uintptr_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
11078 export function CResult__u832APIErrorZ_clone_ptr(arg: number): number {
11079 if(!isWasmInitialized) {
11080 throw new Error("initializeWasm() must be awaited first!");
11082 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
11083 return nativeResponseValue;
11085 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
11087 export function CResult__u832APIErrorZ_clone(orig: number): number {
11088 if(!isWasmInitialized) {
11089 throw new Error("initializeWasm() must be awaited first!");
11091 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
11092 return nativeResponseValue;
11094 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
11096 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): number {
11097 if(!isWasmInitialized) {
11098 throw new Error("initializeWasm() must be awaited first!");
11100 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
11101 return nativeResponseValue;
11103 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11105 export function CResult_PaymentIdPaymentSendFailureZ_err(e: number): number {
11106 if(!isWasmInitialized) {
11107 throw new Error("initializeWasm() must be awaited first!");
11109 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
11110 return nativeResponseValue;
11112 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
11114 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: number): boolean {
11115 if(!isWasmInitialized) {
11116 throw new Error("initializeWasm() must be awaited first!");
11118 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
11119 return nativeResponseValue;
11121 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
11123 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: number): void {
11124 if(!isWasmInitialized) {
11125 throw new Error("initializeWasm() must be awaited first!");
11127 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
11128 // debug statements here
11130 // uintptr_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
11132 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: number): number {
11133 if(!isWasmInitialized) {
11134 throw new Error("initializeWasm() must be awaited first!");
11136 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
11137 return nativeResponseValue;
11139 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
11141 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: number): number {
11142 if(!isWasmInitialized) {
11143 throw new Error("initializeWasm() must be awaited first!");
11145 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
11146 return nativeResponseValue;
11148 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
11150 export function CResult_NonePaymentSendFailureZ_ok(): number {
11151 if(!isWasmInitialized) {
11152 throw new Error("initializeWasm() must be awaited first!");
11154 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
11155 return nativeResponseValue;
11157 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11159 export function CResult_NonePaymentSendFailureZ_err(e: number): number {
11160 if(!isWasmInitialized) {
11161 throw new Error("initializeWasm() must be awaited first!");
11163 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
11164 return nativeResponseValue;
11166 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
11168 export function CResult_NonePaymentSendFailureZ_is_ok(o: number): boolean {
11169 if(!isWasmInitialized) {
11170 throw new Error("initializeWasm() must be awaited first!");
11172 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
11173 return nativeResponseValue;
11175 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
11177 export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
11178 if(!isWasmInitialized) {
11179 throw new Error("initializeWasm() must be awaited first!");
11181 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
11182 // debug statements here
11184 // uintptr_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
11186 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: number): number {
11187 if(!isWasmInitialized) {
11188 throw new Error("initializeWasm() must be awaited first!");
11190 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
11191 return nativeResponseValue;
11193 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
11195 export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
11196 if(!isWasmInitialized) {
11197 throw new Error("initializeWasm() must be awaited first!");
11199 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
11200 return nativeResponseValue;
11202 // uintptr_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
11204 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: number): number {
11205 if(!isWasmInitialized) {
11206 throw new Error("initializeWasm() must be awaited first!");
11208 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
11209 return nativeResponseValue;
11211 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
11213 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: number): number {
11214 if(!isWasmInitialized) {
11215 throw new Error("initializeWasm() must be awaited first!");
11217 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
11218 return nativeResponseValue;
11220 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
11222 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): number {
11223 if(!isWasmInitialized) {
11224 throw new Error("initializeWasm() must be awaited first!");
11226 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
11227 return nativeResponseValue;
11229 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
11231 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: number): void {
11232 if(!isWasmInitialized) {
11233 throw new Error("initializeWasm() must be awaited first!");
11235 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
11236 // debug statements here
11238 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
11240 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: number): number {
11241 if(!isWasmInitialized) {
11242 throw new Error("initializeWasm() must be awaited first!");
11244 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
11245 return nativeResponseValue;
11247 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
11249 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: number): number {
11250 if(!isWasmInitialized) {
11251 throw new Error("initializeWasm() must be awaited first!");
11253 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
11254 return nativeResponseValue;
11256 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
11258 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: number): boolean {
11259 if(!isWasmInitialized) {
11260 throw new Error("initializeWasm() must be awaited first!");
11262 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
11263 return nativeResponseValue;
11265 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
11267 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: number): void {
11268 if(!isWasmInitialized) {
11269 throw new Error("initializeWasm() must be awaited first!");
11271 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
11272 // debug statements here
11274 // uintptr_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
11276 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: number): number {
11277 if(!isWasmInitialized) {
11278 throw new Error("initializeWasm() must be awaited first!");
11280 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
11281 return nativeResponseValue;
11283 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
11285 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: number): number {
11286 if(!isWasmInitialized) {
11287 throw new Error("initializeWasm() must be awaited first!");
11289 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
11290 return nativeResponseValue;
11292 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
11294 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
11295 if(!isWasmInitialized) {
11296 throw new Error("initializeWasm() must be awaited first!");
11298 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
11299 // debug statements here
11301 // uintptr_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
11303 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: number): number {
11304 if(!isWasmInitialized) {
11305 throw new Error("initializeWasm() must be awaited first!");
11307 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
11308 return nativeResponseValue;
11310 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
11312 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: number): number {
11313 if(!isWasmInitialized) {
11314 throw new Error("initializeWasm() must be awaited first!");
11316 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
11317 return nativeResponseValue;
11319 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
11321 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): number {
11322 if(!isWasmInitialized) {
11323 throw new Error("initializeWasm() must be awaited first!");
11325 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
11326 return nativeResponseValue;
11328 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
11330 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: number): void {
11331 if(!isWasmInitialized) {
11332 throw new Error("initializeWasm() must be awaited first!");
11334 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
11335 // debug statements here
11337 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11339 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: number): number {
11340 if(!isWasmInitialized) {
11341 throw new Error("initializeWasm() must be awaited first!");
11343 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
11344 return nativeResponseValue;
11346 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
11348 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): number {
11349 if(!isWasmInitialized) {
11350 throw new Error("initializeWasm() must be awaited first!");
11352 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
11353 return nativeResponseValue;
11355 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
11357 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: number): boolean {
11358 if(!isWasmInitialized) {
11359 throw new Error("initializeWasm() must be awaited first!");
11361 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
11362 return nativeResponseValue;
11364 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
11366 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: number): void {
11367 if(!isWasmInitialized) {
11368 throw new Error("initializeWasm() must be awaited first!");
11370 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
11371 // debug statements here
11373 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
11375 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: number): number {
11376 if(!isWasmInitialized) {
11377 throw new Error("initializeWasm() must be awaited first!");
11379 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
11380 return nativeResponseValue;
11382 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
11384 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: number): number {
11385 if(!isWasmInitialized) {
11386 throw new Error("initializeWasm() must be awaited first!");
11388 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
11389 return nativeResponseValue;
11391 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11393 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: number): number {
11394 if(!isWasmInitialized) {
11395 throw new Error("initializeWasm() must be awaited first!");
11397 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
11398 return nativeResponseValue;
11400 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
11402 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: number): number {
11403 if(!isWasmInitialized) {
11404 throw new Error("initializeWasm() must be awaited first!");
11406 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
11407 return nativeResponseValue;
11409 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
11411 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: number): boolean {
11412 if(!isWasmInitialized) {
11413 throw new Error("initializeWasm() must be awaited first!");
11415 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
11416 return nativeResponseValue;
11418 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
11420 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: number): void {
11421 if(!isWasmInitialized) {
11422 throw new Error("initializeWasm() must be awaited first!");
11424 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
11425 // debug statements here
11427 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
11429 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: number): number {
11430 if(!isWasmInitialized) {
11431 throw new Error("initializeWasm() must be awaited first!");
11433 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
11434 return nativeResponseValue;
11436 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
11438 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: number): number {
11439 if(!isWasmInitialized) {
11440 throw new Error("initializeWasm() must be awaited first!");
11442 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
11443 return nativeResponseValue;
11445 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
11447 export function CResult_PaymentSecretNoneZ_ok(o: number): number {
11448 if(!isWasmInitialized) {
11449 throw new Error("initializeWasm() must be awaited first!");
11451 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
11452 return nativeResponseValue;
11454 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
11456 export function CResult_PaymentSecretNoneZ_err(): number {
11457 if(!isWasmInitialized) {
11458 throw new Error("initializeWasm() must be awaited first!");
11460 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
11461 return nativeResponseValue;
11463 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
11465 export function CResult_PaymentSecretNoneZ_is_ok(o: number): boolean {
11466 if(!isWasmInitialized) {
11467 throw new Error("initializeWasm() must be awaited first!");
11469 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
11470 return nativeResponseValue;
11472 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
11474 export function CResult_PaymentSecretNoneZ_free(_res: number): void {
11475 if(!isWasmInitialized) {
11476 throw new Error("initializeWasm() must be awaited first!");
11478 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
11479 // debug statements here
11481 // uintptr_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
11483 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: number): number {
11484 if(!isWasmInitialized) {
11485 throw new Error("initializeWasm() must be awaited first!");
11487 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
11488 return nativeResponseValue;
11490 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
11492 export function CResult_PaymentSecretNoneZ_clone(orig: number): number {
11493 if(!isWasmInitialized) {
11494 throw new Error("initializeWasm() must be awaited first!");
11496 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
11497 return nativeResponseValue;
11499 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
11501 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): number {
11502 if(!isWasmInitialized) {
11503 throw new Error("initializeWasm() must be awaited first!");
11505 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
11506 return nativeResponseValue;
11508 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
11510 export function CResult_PaymentSecretAPIErrorZ_err(e: number): number {
11511 if(!isWasmInitialized) {
11512 throw new Error("initializeWasm() must be awaited first!");
11514 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
11515 return nativeResponseValue;
11517 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
11519 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: number): boolean {
11520 if(!isWasmInitialized) {
11521 throw new Error("initializeWasm() must be awaited first!");
11523 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
11524 return nativeResponseValue;
11526 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
11528 export function CResult_PaymentSecretAPIErrorZ_free(_res: number): void {
11529 if(!isWasmInitialized) {
11530 throw new Error("initializeWasm() must be awaited first!");
11532 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
11533 // debug statements here
11535 // uintptr_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
11537 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: number): number {
11538 if(!isWasmInitialized) {
11539 throw new Error("initializeWasm() must be awaited first!");
11541 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
11542 return nativeResponseValue;
11544 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
11546 export function CResult_PaymentSecretAPIErrorZ_clone(orig: number): number {
11547 if(!isWasmInitialized) {
11548 throw new Error("initializeWasm() must be awaited first!");
11550 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
11551 return nativeResponseValue;
11553 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
11555 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): number {
11556 if(!isWasmInitialized) {
11557 throw new Error("initializeWasm() must be awaited first!");
11559 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
11560 return nativeResponseValue;
11562 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
11564 export function CResult_PaymentPreimageAPIErrorZ_err(e: number): number {
11565 if(!isWasmInitialized) {
11566 throw new Error("initializeWasm() must be awaited first!");
11568 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
11569 return nativeResponseValue;
11571 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
11573 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: number): boolean {
11574 if(!isWasmInitialized) {
11575 throw new Error("initializeWasm() must be awaited first!");
11577 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
11578 return nativeResponseValue;
11580 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
11582 export function CResult_PaymentPreimageAPIErrorZ_free(_res: number): void {
11583 if(!isWasmInitialized) {
11584 throw new Error("initializeWasm() must be awaited first!");
11586 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
11587 // debug statements here
11589 // uintptr_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
11591 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: number): number {
11592 if(!isWasmInitialized) {
11593 throw new Error("initializeWasm() must be awaited first!");
11595 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
11596 return nativeResponseValue;
11598 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
11600 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: number): number {
11601 if(!isWasmInitialized) {
11602 throw new Error("initializeWasm() must be awaited first!");
11604 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
11605 return nativeResponseValue;
11607 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
11609 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: number): number {
11610 if(!isWasmInitialized) {
11611 throw new Error("initializeWasm() must be awaited first!");
11613 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
11614 return nativeResponseValue;
11616 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
11618 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: number): number {
11619 if(!isWasmInitialized) {
11620 throw new Error("initializeWasm() must be awaited first!");
11622 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
11623 return nativeResponseValue;
11625 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
11627 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: number): boolean {
11628 if(!isWasmInitialized) {
11629 throw new Error("initializeWasm() must be awaited first!");
11631 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
11632 return nativeResponseValue;
11634 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
11636 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: number): void {
11637 if(!isWasmInitialized) {
11638 throw new Error("initializeWasm() must be awaited first!");
11640 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
11641 // debug statements here
11643 // uintptr_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
11645 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: number): number {
11646 if(!isWasmInitialized) {
11647 throw new Error("initializeWasm() must be awaited first!");
11649 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
11650 return nativeResponseValue;
11652 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
11654 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: number): number {
11655 if(!isWasmInitialized) {
11656 throw new Error("initializeWasm() must be awaited first!");
11658 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
11659 return nativeResponseValue;
11661 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
11663 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: number): number {
11664 if(!isWasmInitialized) {
11665 throw new Error("initializeWasm() must be awaited first!");
11667 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
11668 return nativeResponseValue;
11670 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
11672 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: number): number {
11673 if(!isWasmInitialized) {
11674 throw new Error("initializeWasm() must be awaited first!");
11676 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
11677 return nativeResponseValue;
11679 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
11681 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: number): boolean {
11682 if(!isWasmInitialized) {
11683 throw new Error("initializeWasm() must be awaited first!");
11685 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
11686 return nativeResponseValue;
11688 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
11690 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: number): void {
11691 if(!isWasmInitialized) {
11692 throw new Error("initializeWasm() must be awaited first!");
11694 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
11695 // debug statements here
11697 // uintptr_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
11699 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: number): number {
11700 if(!isWasmInitialized) {
11701 throw new Error("initializeWasm() must be awaited first!");
11703 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
11704 return nativeResponseValue;
11706 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
11708 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: number): number {
11709 if(!isWasmInitialized) {
11710 throw new Error("initializeWasm() must be awaited first!");
11712 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
11713 return nativeResponseValue;
11715 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
11717 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: number): number {
11718 if(!isWasmInitialized) {
11719 throw new Error("initializeWasm() must be awaited first!");
11721 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
11722 return nativeResponseValue;
11724 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
11726 export function CResult_ChannelDetailsDecodeErrorZ_err(e: number): number {
11727 if(!isWasmInitialized) {
11728 throw new Error("initializeWasm() must be awaited first!");
11730 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
11731 return nativeResponseValue;
11733 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
11735 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: number): boolean {
11736 if(!isWasmInitialized) {
11737 throw new Error("initializeWasm() must be awaited first!");
11739 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
11740 return nativeResponseValue;
11742 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
11744 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: number): void {
11745 if(!isWasmInitialized) {
11746 throw new Error("initializeWasm() must be awaited first!");
11748 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
11749 // debug statements here
11751 // uintptr_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
11753 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: number): number {
11754 if(!isWasmInitialized) {
11755 throw new Error("initializeWasm() must be awaited first!");
11757 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
11758 return nativeResponseValue;
11760 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
11762 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: number): number {
11763 if(!isWasmInitialized) {
11764 throw new Error("initializeWasm() must be awaited first!");
11766 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
11767 return nativeResponseValue;
11769 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
11771 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: number): number {
11772 if(!isWasmInitialized) {
11773 throw new Error("initializeWasm() must be awaited first!");
11775 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
11776 return nativeResponseValue;
11778 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
11780 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: number): number {
11781 if(!isWasmInitialized) {
11782 throw new Error("initializeWasm() must be awaited first!");
11784 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
11785 return nativeResponseValue;
11787 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
11789 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: number): boolean {
11790 if(!isWasmInitialized) {
11791 throw new Error("initializeWasm() must be awaited first!");
11793 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
11794 return nativeResponseValue;
11796 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
11798 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: number): void {
11799 if(!isWasmInitialized) {
11800 throw new Error("initializeWasm() must be awaited first!");
11802 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
11803 // debug statements here
11805 // uintptr_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
11807 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: number): number {
11808 if(!isWasmInitialized) {
11809 throw new Error("initializeWasm() must be awaited first!");
11811 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
11812 return nativeResponseValue;
11814 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
11816 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: number): number {
11817 if(!isWasmInitialized) {
11818 throw new Error("initializeWasm() must be awaited first!");
11820 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
11821 return nativeResponseValue;
11823 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
11825 export function CVec_ChannelMonitorZ_free(_res: number): void {
11826 if(!isWasmInitialized) {
11827 throw new Error("initializeWasm() must be awaited first!");
11829 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
11830 // debug statements here
11832 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
11834 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: number): number {
11835 if(!isWasmInitialized) {
11836 throw new Error("initializeWasm() must be awaited first!");
11838 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
11839 return nativeResponseValue;
11841 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
11843 export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
11844 if(!isWasmInitialized) {
11845 throw new Error("initializeWasm() must be awaited first!");
11847 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
11848 // debug statements here
11850 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
11852 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
11853 if(!isWasmInitialized) {
11854 throw new Error("initializeWasm() must be awaited first!");
11856 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
11857 return nativeResponseValue;
11859 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
11861 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
11862 if(!isWasmInitialized) {
11863 throw new Error("initializeWasm() must be awaited first!");
11865 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
11866 return nativeResponseValue;
11868 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
11870 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: number): boolean {
11871 if(!isWasmInitialized) {
11872 throw new Error("initializeWasm() must be awaited first!");
11874 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
11875 return nativeResponseValue;
11877 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
11879 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
11880 if(!isWasmInitialized) {
11881 throw new Error("initializeWasm() must be awaited first!");
11883 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
11884 // debug statements here
11886 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
11888 export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
11889 if(!isWasmInitialized) {
11890 throw new Error("initializeWasm() must be awaited first!");
11892 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
11893 return nativeResponseValue;
11895 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
11897 export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
11898 if(!isWasmInitialized) {
11899 throw new Error("initializeWasm() must be awaited first!");
11901 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
11902 return nativeResponseValue;
11904 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
11906 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: number): boolean {
11907 if(!isWasmInitialized) {
11908 throw new Error("initializeWasm() must be awaited first!");
11910 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
11911 return nativeResponseValue;
11913 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
11915 export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
11916 if(!isWasmInitialized) {
11917 throw new Error("initializeWasm() must be awaited first!");
11919 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
11920 // debug statements here
11922 // uintptr_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
11924 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: number): number {
11925 if(!isWasmInitialized) {
11926 throw new Error("initializeWasm() must be awaited first!");
11928 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
11929 return nativeResponseValue;
11931 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
11933 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
11934 if(!isWasmInitialized) {
11935 throw new Error("initializeWasm() must be awaited first!");
11937 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
11938 return nativeResponseValue;
11940 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
11942 export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
11943 if(!isWasmInitialized) {
11944 throw new Error("initializeWasm() must be awaited first!");
11946 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
11947 return nativeResponseValue;
11949 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
11951 export function CResult_OutPointDecodeErrorZ_err(e: number): number {
11952 if(!isWasmInitialized) {
11953 throw new Error("initializeWasm() must be awaited first!");
11955 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
11956 return nativeResponseValue;
11958 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
11960 export function CResult_OutPointDecodeErrorZ_is_ok(o: number): boolean {
11961 if(!isWasmInitialized) {
11962 throw new Error("initializeWasm() must be awaited first!");
11964 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
11965 return nativeResponseValue;
11967 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
11969 export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
11970 if(!isWasmInitialized) {
11971 throw new Error("initializeWasm() must be awaited first!");
11973 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
11974 // debug statements here
11976 // uintptr_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
11978 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: number): number {
11979 if(!isWasmInitialized) {
11980 throw new Error("initializeWasm() must be awaited first!");
11982 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
11983 return nativeResponseValue;
11985 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
11987 export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
11988 if(!isWasmInitialized) {
11989 throw new Error("initializeWasm() must be awaited first!");
11991 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
11992 return nativeResponseValue;
11994 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
11996 export function COption_TypeZ_some(o: number): number {
11997 if(!isWasmInitialized) {
11998 throw new Error("initializeWasm() must be awaited first!");
12000 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
12001 return nativeResponseValue;
12003 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
12005 export function COption_TypeZ_none(): number {
12006 if(!isWasmInitialized) {
12007 throw new Error("initializeWasm() must be awaited first!");
12009 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
12010 return nativeResponseValue;
12012 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
12014 export function COption_TypeZ_free(_res: number): void {
12015 if(!isWasmInitialized) {
12016 throw new Error("initializeWasm() must be awaited first!");
12018 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
12019 // debug statements here
12021 // uintptr_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
12023 export function COption_TypeZ_clone_ptr(arg: number): number {
12024 if(!isWasmInitialized) {
12025 throw new Error("initializeWasm() must be awaited first!");
12027 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
12028 return nativeResponseValue;
12030 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
12032 export function COption_TypeZ_clone(orig: number): number {
12033 if(!isWasmInitialized) {
12034 throw new Error("initializeWasm() must be awaited first!");
12036 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
12037 return nativeResponseValue;
12039 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
12041 export function CResult_COption_TypeZDecodeErrorZ_ok(o: number): number {
12042 if(!isWasmInitialized) {
12043 throw new Error("initializeWasm() must be awaited first!");
12045 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
12046 return nativeResponseValue;
12048 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
12050 export function CResult_COption_TypeZDecodeErrorZ_err(e: number): number {
12051 if(!isWasmInitialized) {
12052 throw new Error("initializeWasm() must be awaited first!");
12054 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
12055 return nativeResponseValue;
12057 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
12059 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: number): boolean {
12060 if(!isWasmInitialized) {
12061 throw new Error("initializeWasm() must be awaited first!");
12063 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
12064 return nativeResponseValue;
12066 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
12068 export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
12069 if(!isWasmInitialized) {
12070 throw new Error("initializeWasm() must be awaited first!");
12072 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
12073 // debug statements here
12075 // uintptr_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
12077 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: number): number {
12078 if(!isWasmInitialized) {
12079 throw new Error("initializeWasm() must be awaited first!");
12081 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
12082 return nativeResponseValue;
12084 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
12086 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
12087 if(!isWasmInitialized) {
12088 throw new Error("initializeWasm() must be awaited first!");
12090 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
12091 return nativeResponseValue;
12093 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
12095 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): number {
12096 if(!isWasmInitialized) {
12097 throw new Error("initializeWasm() must be awaited first!");
12099 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
12100 return nativeResponseValue;
12102 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
12104 export function CResult_PaymentIdPaymentErrorZ_err(e: number): number {
12105 if(!isWasmInitialized) {
12106 throw new Error("initializeWasm() must be awaited first!");
12108 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
12109 return nativeResponseValue;
12111 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
12113 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: number): boolean {
12114 if(!isWasmInitialized) {
12115 throw new Error("initializeWasm() must be awaited first!");
12117 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
12118 return nativeResponseValue;
12120 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
12122 export function CResult_PaymentIdPaymentErrorZ_free(_res: number): void {
12123 if(!isWasmInitialized) {
12124 throw new Error("initializeWasm() must be awaited first!");
12126 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
12127 // debug statements here
12129 // uintptr_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
12131 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: number): number {
12132 if(!isWasmInitialized) {
12133 throw new Error("initializeWasm() must be awaited first!");
12135 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
12136 return nativeResponseValue;
12138 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
12140 export function CResult_PaymentIdPaymentErrorZ_clone(orig: number): number {
12141 if(!isWasmInitialized) {
12142 throw new Error("initializeWasm() must be awaited first!");
12144 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
12145 return nativeResponseValue;
12147 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
12149 export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): number {
12150 if(!isWasmInitialized) {
12151 throw new Error("initializeWasm() must be awaited first!");
12153 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
12154 return nativeResponseValue;
12156 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
12158 export function CResult_SiPrefixParseErrorZ_err(e: number): number {
12159 if(!isWasmInitialized) {
12160 throw new Error("initializeWasm() must be awaited first!");
12162 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
12163 return nativeResponseValue;
12165 // bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
12167 export function CResult_SiPrefixParseErrorZ_is_ok(o: number): boolean {
12168 if(!isWasmInitialized) {
12169 throw new Error("initializeWasm() must be awaited first!");
12171 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
12172 return nativeResponseValue;
12174 // void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
12176 export function CResult_SiPrefixParseErrorZ_free(_res: number): void {
12177 if(!isWasmInitialized) {
12178 throw new Error("initializeWasm() must be awaited first!");
12180 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
12181 // debug statements here
12183 // uintptr_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
12185 export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: number): number {
12186 if(!isWasmInitialized) {
12187 throw new Error("initializeWasm() must be awaited first!");
12189 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
12190 return nativeResponseValue;
12192 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
12194 export function CResult_SiPrefixParseErrorZ_clone(orig: number): number {
12195 if(!isWasmInitialized) {
12196 throw new Error("initializeWasm() must be awaited first!");
12198 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
12199 return nativeResponseValue;
12201 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
12203 export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: number): number {
12204 if(!isWasmInitialized) {
12205 throw new Error("initializeWasm() must be awaited first!");
12207 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
12208 return nativeResponseValue;
12210 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
12212 export function CResult_InvoiceParseOrSemanticErrorZ_err(e: number): number {
12213 if(!isWasmInitialized) {
12214 throw new Error("initializeWasm() must be awaited first!");
12216 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
12217 return nativeResponseValue;
12219 // bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
12221 export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: number): boolean {
12222 if(!isWasmInitialized) {
12223 throw new Error("initializeWasm() must be awaited first!");
12225 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
12226 return nativeResponseValue;
12228 // void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
12230 export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: number): void {
12231 if(!isWasmInitialized) {
12232 throw new Error("initializeWasm() must be awaited first!");
12234 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
12235 // debug statements here
12237 // uintptr_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
12239 export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: number): number {
12240 if(!isWasmInitialized) {
12241 throw new Error("initializeWasm() must be awaited first!");
12243 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
12244 return nativeResponseValue;
12246 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
12248 export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: number): number {
12249 if(!isWasmInitialized) {
12250 throw new Error("initializeWasm() must be awaited first!");
12252 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
12253 return nativeResponseValue;
12255 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
12257 export function CResult_SignedRawInvoiceParseErrorZ_ok(o: number): number {
12258 if(!isWasmInitialized) {
12259 throw new Error("initializeWasm() must be awaited first!");
12261 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
12262 return nativeResponseValue;
12264 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
12266 export function CResult_SignedRawInvoiceParseErrorZ_err(e: number): number {
12267 if(!isWasmInitialized) {
12268 throw new Error("initializeWasm() must be awaited first!");
12270 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
12271 return nativeResponseValue;
12273 // bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
12275 export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: number): boolean {
12276 if(!isWasmInitialized) {
12277 throw new Error("initializeWasm() must be awaited first!");
12279 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
12280 return nativeResponseValue;
12282 // void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
12284 export function CResult_SignedRawInvoiceParseErrorZ_free(_res: number): void {
12285 if(!isWasmInitialized) {
12286 throw new Error("initializeWasm() must be awaited first!");
12288 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
12289 // debug statements here
12291 // uintptr_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
12293 export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: number): number {
12294 if(!isWasmInitialized) {
12295 throw new Error("initializeWasm() must be awaited first!");
12297 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
12298 return nativeResponseValue;
12300 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
12302 export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: number): number {
12303 if(!isWasmInitialized) {
12304 throw new Error("initializeWasm() must be awaited first!");
12306 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
12307 return nativeResponseValue;
12309 // uintptr_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
12311 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: number): number {
12312 if(!isWasmInitialized) {
12313 throw new Error("initializeWasm() must be awaited first!");
12315 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
12316 return nativeResponseValue;
12318 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
12320 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: number): number {
12321 if(!isWasmInitialized) {
12322 throw new Error("initializeWasm() must be awaited first!");
12324 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
12325 return nativeResponseValue;
12327 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
12329 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: number, b: number, c: number): number {
12330 if(!isWasmInitialized) {
12331 throw new Error("initializeWasm() must be awaited first!");
12333 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
12334 return nativeResponseValue;
12336 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
12338 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: number): void {
12339 if(!isWasmInitialized) {
12340 throw new Error("initializeWasm() must be awaited first!");
12342 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
12343 // debug statements here
12345 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
12347 export function CResult_PayeePubKeyErrorZ_ok(o: number): number {
12348 if(!isWasmInitialized) {
12349 throw new Error("initializeWasm() must be awaited first!");
12351 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
12352 return nativeResponseValue;
12354 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
12356 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): number {
12357 if(!isWasmInitialized) {
12358 throw new Error("initializeWasm() must be awaited first!");
12360 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
12361 return nativeResponseValue;
12363 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
12365 export function CResult_PayeePubKeyErrorZ_is_ok(o: number): boolean {
12366 if(!isWasmInitialized) {
12367 throw new Error("initializeWasm() must be awaited first!");
12369 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
12370 return nativeResponseValue;
12372 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
12374 export function CResult_PayeePubKeyErrorZ_free(_res: number): void {
12375 if(!isWasmInitialized) {
12376 throw new Error("initializeWasm() must be awaited first!");
12378 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
12379 // debug statements here
12381 // uintptr_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
12383 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: number): number {
12384 if(!isWasmInitialized) {
12385 throw new Error("initializeWasm() must be awaited first!");
12387 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
12388 return nativeResponseValue;
12390 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
12392 export function CResult_PayeePubKeyErrorZ_clone(orig: number): number {
12393 if(!isWasmInitialized) {
12394 throw new Error("initializeWasm() must be awaited first!");
12396 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
12397 return nativeResponseValue;
12399 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
12401 export function CVec_PrivateRouteZ_free(_res: number): void {
12402 if(!isWasmInitialized) {
12403 throw new Error("initializeWasm() must be awaited first!");
12405 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
12406 // debug statements here
12408 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
12410 export function CResult_PositiveTimestampCreationErrorZ_ok(o: number): number {
12411 if(!isWasmInitialized) {
12412 throw new Error("initializeWasm() must be awaited first!");
12414 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
12415 return nativeResponseValue;
12417 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
12419 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): number {
12420 if(!isWasmInitialized) {
12421 throw new Error("initializeWasm() must be awaited first!");
12423 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
12424 return nativeResponseValue;
12426 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
12428 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: number): boolean {
12429 if(!isWasmInitialized) {
12430 throw new Error("initializeWasm() must be awaited first!");
12432 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
12433 return nativeResponseValue;
12435 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
12437 export function CResult_PositiveTimestampCreationErrorZ_free(_res: number): void {
12438 if(!isWasmInitialized) {
12439 throw new Error("initializeWasm() must be awaited first!");
12441 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
12442 // debug statements here
12444 // uintptr_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
12446 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: number): number {
12447 if(!isWasmInitialized) {
12448 throw new Error("initializeWasm() must be awaited first!");
12450 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
12451 return nativeResponseValue;
12453 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
12455 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: number): number {
12456 if(!isWasmInitialized) {
12457 throw new Error("initializeWasm() must be awaited first!");
12459 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
12460 return nativeResponseValue;
12462 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
12464 export function CResult_NoneSemanticErrorZ_ok(): number {
12465 if(!isWasmInitialized) {
12466 throw new Error("initializeWasm() must be awaited first!");
12468 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
12469 return nativeResponseValue;
12471 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
12473 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): number {
12474 if(!isWasmInitialized) {
12475 throw new Error("initializeWasm() must be awaited first!");
12477 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
12478 return nativeResponseValue;
12480 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
12482 export function CResult_NoneSemanticErrorZ_is_ok(o: number): boolean {
12483 if(!isWasmInitialized) {
12484 throw new Error("initializeWasm() must be awaited first!");
12486 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
12487 return nativeResponseValue;
12489 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
12491 export function CResult_NoneSemanticErrorZ_free(_res: number): void {
12492 if(!isWasmInitialized) {
12493 throw new Error("initializeWasm() must be awaited first!");
12495 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
12496 // debug statements here
12498 // uintptr_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
12500 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: number): number {
12501 if(!isWasmInitialized) {
12502 throw new Error("initializeWasm() must be awaited first!");
12504 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
12505 return nativeResponseValue;
12507 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
12509 export function CResult_NoneSemanticErrorZ_clone(orig: number): number {
12510 if(!isWasmInitialized) {
12511 throw new Error("initializeWasm() must be awaited first!");
12513 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
12514 return nativeResponseValue;
12516 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
12518 export function CResult_InvoiceSemanticErrorZ_ok(o: number): number {
12519 if(!isWasmInitialized) {
12520 throw new Error("initializeWasm() must be awaited first!");
12522 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
12523 return nativeResponseValue;
12525 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
12527 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): number {
12528 if(!isWasmInitialized) {
12529 throw new Error("initializeWasm() must be awaited first!");
12531 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
12532 return nativeResponseValue;
12534 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
12536 export function CResult_InvoiceSemanticErrorZ_is_ok(o: number): boolean {
12537 if(!isWasmInitialized) {
12538 throw new Error("initializeWasm() must be awaited first!");
12540 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
12541 return nativeResponseValue;
12543 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
12545 export function CResult_InvoiceSemanticErrorZ_free(_res: number): void {
12546 if(!isWasmInitialized) {
12547 throw new Error("initializeWasm() must be awaited first!");
12549 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
12550 // debug statements here
12552 // uintptr_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
12554 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: number): number {
12555 if(!isWasmInitialized) {
12556 throw new Error("initializeWasm() must be awaited first!");
12558 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
12559 return nativeResponseValue;
12561 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
12563 export function CResult_InvoiceSemanticErrorZ_clone(orig: number): number {
12564 if(!isWasmInitialized) {
12565 throw new Error("initializeWasm() must be awaited first!");
12567 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
12568 return nativeResponseValue;
12570 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
12572 export function CResult_DescriptionCreationErrorZ_ok(o: number): number {
12573 if(!isWasmInitialized) {
12574 throw new Error("initializeWasm() must be awaited first!");
12576 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
12577 return nativeResponseValue;
12579 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
12581 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): number {
12582 if(!isWasmInitialized) {
12583 throw new Error("initializeWasm() must be awaited first!");
12585 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
12586 return nativeResponseValue;
12588 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
12590 export function CResult_DescriptionCreationErrorZ_is_ok(o: number): boolean {
12591 if(!isWasmInitialized) {
12592 throw new Error("initializeWasm() must be awaited first!");
12594 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
12595 return nativeResponseValue;
12597 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
12599 export function CResult_DescriptionCreationErrorZ_free(_res: number): void {
12600 if(!isWasmInitialized) {
12601 throw new Error("initializeWasm() must be awaited first!");
12603 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
12604 // debug statements here
12606 // uintptr_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
12608 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: number): number {
12609 if(!isWasmInitialized) {
12610 throw new Error("initializeWasm() must be awaited first!");
12612 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
12613 return nativeResponseValue;
12615 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
12617 export function CResult_DescriptionCreationErrorZ_clone(orig: number): number {
12618 if(!isWasmInitialized) {
12619 throw new Error("initializeWasm() must be awaited first!");
12621 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
12622 return nativeResponseValue;
12624 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
12626 export function CResult_PrivateRouteCreationErrorZ_ok(o: number): number {
12627 if(!isWasmInitialized) {
12628 throw new Error("initializeWasm() must be awaited first!");
12630 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
12631 return nativeResponseValue;
12633 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
12635 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): number {
12636 if(!isWasmInitialized) {
12637 throw new Error("initializeWasm() must be awaited first!");
12639 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
12640 return nativeResponseValue;
12642 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
12644 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: number): boolean {
12645 if(!isWasmInitialized) {
12646 throw new Error("initializeWasm() must be awaited first!");
12648 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
12649 return nativeResponseValue;
12651 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
12653 export function CResult_PrivateRouteCreationErrorZ_free(_res: number): void {
12654 if(!isWasmInitialized) {
12655 throw new Error("initializeWasm() must be awaited first!");
12657 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
12658 // debug statements here
12660 // uintptr_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
12662 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: number): number {
12663 if(!isWasmInitialized) {
12664 throw new Error("initializeWasm() must be awaited first!");
12666 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
12667 return nativeResponseValue;
12669 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
12671 export function CResult_PrivateRouteCreationErrorZ_clone(orig: number): number {
12672 if(!isWasmInitialized) {
12673 throw new Error("initializeWasm() must be awaited first!");
12675 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
12676 return nativeResponseValue;
12678 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
12680 export function CResult_StringErrorZ_ok(o: number): number {
12681 if(!isWasmInitialized) {
12682 throw new Error("initializeWasm() must be awaited first!");
12684 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
12685 return nativeResponseValue;
12687 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
12689 export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
12690 if(!isWasmInitialized) {
12691 throw new Error("initializeWasm() must be awaited first!");
12693 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
12694 return nativeResponseValue;
12696 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
12698 export function CResult_StringErrorZ_is_ok(o: number): boolean {
12699 if(!isWasmInitialized) {
12700 throw new Error("initializeWasm() must be awaited first!");
12702 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
12703 return nativeResponseValue;
12705 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
12707 export function CResult_StringErrorZ_free(_res: number): void {
12708 if(!isWasmInitialized) {
12709 throw new Error("initializeWasm() must be awaited first!");
12711 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
12712 // debug statements here
12714 // uintptr_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg);
12716 export function CResult_StringErrorZ_clone_ptr(arg: number): number {
12717 if(!isWasmInitialized) {
12718 throw new Error("initializeWasm() must be awaited first!");
12720 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone_ptr(arg);
12721 return nativeResponseValue;
12723 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_clone(const struct LDKCResult_StringErrorZ *NONNULL_PTR orig);
12725 export function CResult_StringErrorZ_clone(orig: number): number {
12726 if(!isWasmInitialized) {
12727 throw new Error("initializeWasm() must be awaited first!");
12729 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
12730 return nativeResponseValue;
12732 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
12734 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
12735 if(!isWasmInitialized) {
12736 throw new Error("initializeWasm() must be awaited first!");
12738 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
12739 return nativeResponseValue;
12741 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12743 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
12744 if(!isWasmInitialized) {
12745 throw new Error("initializeWasm() must be awaited first!");
12747 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
12748 return nativeResponseValue;
12750 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
12752 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: number): boolean {
12753 if(!isWasmInitialized) {
12754 throw new Error("initializeWasm() must be awaited first!");
12756 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
12757 return nativeResponseValue;
12759 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
12761 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
12762 if(!isWasmInitialized) {
12763 throw new Error("initializeWasm() must be awaited first!");
12765 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
12766 // debug statements here
12768 // uintptr_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
12770 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: number): number {
12771 if(!isWasmInitialized) {
12772 throw new Error("initializeWasm() must be awaited first!");
12774 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
12775 return nativeResponseValue;
12777 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
12779 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
12780 if(!isWasmInitialized) {
12781 throw new Error("initializeWasm() must be awaited first!");
12783 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
12784 return nativeResponseValue;
12786 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
12788 export function COption_MonitorEventZ_some(o: number): number {
12789 if(!isWasmInitialized) {
12790 throw new Error("initializeWasm() must be awaited first!");
12792 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
12793 return nativeResponseValue;
12795 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
12797 export function COption_MonitorEventZ_none(): number {
12798 if(!isWasmInitialized) {
12799 throw new Error("initializeWasm() must be awaited first!");
12801 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
12802 return nativeResponseValue;
12804 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
12806 export function COption_MonitorEventZ_free(_res: number): void {
12807 if(!isWasmInitialized) {
12808 throw new Error("initializeWasm() must be awaited first!");
12810 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
12811 // debug statements here
12813 // uintptr_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
12815 export function COption_MonitorEventZ_clone_ptr(arg: number): number {
12816 if(!isWasmInitialized) {
12817 throw new Error("initializeWasm() must be awaited first!");
12819 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
12820 return nativeResponseValue;
12822 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
12824 export function COption_MonitorEventZ_clone(orig: number): number {
12825 if(!isWasmInitialized) {
12826 throw new Error("initializeWasm() must be awaited first!");
12828 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
12829 return nativeResponseValue;
12831 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
12833 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: number): number {
12834 if(!isWasmInitialized) {
12835 throw new Error("initializeWasm() must be awaited first!");
12837 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
12838 return nativeResponseValue;
12840 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
12842 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: number): number {
12843 if(!isWasmInitialized) {
12844 throw new Error("initializeWasm() must be awaited first!");
12846 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
12847 return nativeResponseValue;
12849 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
12851 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: number): boolean {
12852 if(!isWasmInitialized) {
12853 throw new Error("initializeWasm() must be awaited first!");
12855 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
12856 return nativeResponseValue;
12858 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
12860 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: number): void {
12861 if(!isWasmInitialized) {
12862 throw new Error("initializeWasm() must be awaited first!");
12864 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
12865 // debug statements here
12867 // uintptr_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
12869 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: number): number {
12870 if(!isWasmInitialized) {
12871 throw new Error("initializeWasm() must be awaited first!");
12873 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
12874 return nativeResponseValue;
12876 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
12878 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: number): number {
12879 if(!isWasmInitialized) {
12880 throw new Error("initializeWasm() must be awaited first!");
12882 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
12883 return nativeResponseValue;
12885 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
12887 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
12888 if(!isWasmInitialized) {
12889 throw new Error("initializeWasm() must be awaited first!");
12891 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
12892 return nativeResponseValue;
12894 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12896 export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
12897 if(!isWasmInitialized) {
12898 throw new Error("initializeWasm() must be awaited first!");
12900 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
12901 return nativeResponseValue;
12903 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
12905 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: number): boolean {
12906 if(!isWasmInitialized) {
12907 throw new Error("initializeWasm() must be awaited first!");
12909 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
12910 return nativeResponseValue;
12912 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
12914 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
12915 if(!isWasmInitialized) {
12916 throw new Error("initializeWasm() must be awaited first!");
12918 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
12919 // debug statements here
12921 // uintptr_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
12923 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: number): number {
12924 if(!isWasmInitialized) {
12925 throw new Error("initializeWasm() must be awaited first!");
12927 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
12928 return nativeResponseValue;
12930 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
12932 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
12933 if(!isWasmInitialized) {
12934 throw new Error("initializeWasm() must be awaited first!");
12936 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
12937 return nativeResponseValue;
12939 // uintptr_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
12941 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: number): number {
12942 if(!isWasmInitialized) {
12943 throw new Error("initializeWasm() must be awaited first!");
12945 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
12946 return nativeResponseValue;
12948 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
12950 export function C2Tuple_OutPointScriptZ_clone(orig: number): number {
12951 if(!isWasmInitialized) {
12952 throw new Error("initializeWasm() must be awaited first!");
12954 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
12955 return nativeResponseValue;
12957 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
12959 export function C2Tuple_OutPointScriptZ_new(a: number, b: number): number {
12960 if(!isWasmInitialized) {
12961 throw new Error("initializeWasm() must be awaited first!");
12963 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
12964 return nativeResponseValue;
12966 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
12968 export function C2Tuple_OutPointScriptZ_free(_res: number): void {
12969 if(!isWasmInitialized) {
12970 throw new Error("initializeWasm() must be awaited first!");
12972 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
12973 // debug statements here
12975 // uintptr_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
12977 export function C2Tuple_u32ScriptZ_clone_ptr(arg: number): number {
12978 if(!isWasmInitialized) {
12979 throw new Error("initializeWasm() must be awaited first!");
12981 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
12982 return nativeResponseValue;
12984 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
12986 export function C2Tuple_u32ScriptZ_clone(orig: number): number {
12987 if(!isWasmInitialized) {
12988 throw new Error("initializeWasm() must be awaited first!");
12990 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
12991 return nativeResponseValue;
12993 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
12995 export function C2Tuple_u32ScriptZ_new(a: number, b: number): number {
12996 if(!isWasmInitialized) {
12997 throw new Error("initializeWasm() must be awaited first!");
12999 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
13000 return nativeResponseValue;
13002 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
13004 export function C2Tuple_u32ScriptZ_free(_res: number): void {
13005 if(!isWasmInitialized) {
13006 throw new Error("initializeWasm() must be awaited first!");
13008 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
13009 // debug statements here
13011 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
13013 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
13014 if(!isWasmInitialized) {
13015 throw new Error("initializeWasm() must be awaited first!");
13017 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
13018 // debug statements here
13020 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
13022 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: number): number {
13023 if(!isWasmInitialized) {
13024 throw new Error("initializeWasm() must be awaited first!");
13026 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
13027 return nativeResponseValue;
13029 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
13031 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: number): number {
13032 if(!isWasmInitialized) {
13033 throw new Error("initializeWasm() must be awaited first!");
13035 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
13036 return nativeResponseValue;
13038 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
13040 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): number {
13041 if(!isWasmInitialized) {
13042 throw new Error("initializeWasm() must be awaited first!");
13044 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
13045 return nativeResponseValue;
13047 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
13049 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: number): void {
13050 if(!isWasmInitialized) {
13051 throw new Error("initializeWasm() must be awaited first!");
13053 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
13054 // debug statements here
13056 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
13058 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
13059 if(!isWasmInitialized) {
13060 throw new Error("initializeWasm() must be awaited first!");
13062 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
13063 // debug statements here
13065 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
13067 export function CVec_EventZ_free(_res: number): void {
13068 if(!isWasmInitialized) {
13069 throw new Error("initializeWasm() must be awaited first!");
13071 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
13072 // debug statements here
13074 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
13076 export function CVec_TransactionZ_free(_res: number): void {
13077 if(!isWasmInitialized) {
13078 throw new Error("initializeWasm() must be awaited first!");
13080 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
13081 // debug statements here
13083 // uintptr_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
13085 export function C2Tuple_u32TxOutZ_clone_ptr(arg: number): number {
13086 if(!isWasmInitialized) {
13087 throw new Error("initializeWasm() must be awaited first!");
13089 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
13090 return nativeResponseValue;
13092 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
13094 export function C2Tuple_u32TxOutZ_clone(orig: number): number {
13095 if(!isWasmInitialized) {
13096 throw new Error("initializeWasm() must be awaited first!");
13098 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
13099 return nativeResponseValue;
13101 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
13103 export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
13104 if(!isWasmInitialized) {
13105 throw new Error("initializeWasm() must be awaited first!");
13107 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
13108 return nativeResponseValue;
13110 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
13112 export function C2Tuple_u32TxOutZ_free(_res: number): void {
13113 if(!isWasmInitialized) {
13114 throw new Error("initializeWasm() must be awaited first!");
13116 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
13117 // debug statements here
13119 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
13121 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
13122 if(!isWasmInitialized) {
13123 throw new Error("initializeWasm() must be awaited first!");
13125 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
13126 // debug statements here
13128 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
13130 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: number): number {
13131 if(!isWasmInitialized) {
13132 throw new Error("initializeWasm() must be awaited first!");
13134 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
13135 return nativeResponseValue;
13137 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
13139 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: number): number {
13140 if(!isWasmInitialized) {
13141 throw new Error("initializeWasm() must be awaited first!");
13143 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
13144 return nativeResponseValue;
13146 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
13148 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): number {
13149 if(!isWasmInitialized) {
13150 throw new Error("initializeWasm() must be awaited first!");
13152 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
13153 return nativeResponseValue;
13155 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
13157 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
13158 if(!isWasmInitialized) {
13159 throw new Error("initializeWasm() must be awaited first!");
13161 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
13162 // debug statements here
13164 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
13166 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
13167 if(!isWasmInitialized) {
13168 throw new Error("initializeWasm() must be awaited first!");
13170 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
13171 // debug statements here
13173 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
13175 export function CVec_BalanceZ_free(_res: number): void {
13176 if(!isWasmInitialized) {
13177 throw new Error("initializeWasm() must be awaited first!");
13179 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
13180 // debug statements here
13182 // uintptr_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
13184 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: number): number {
13185 if(!isWasmInitialized) {
13186 throw new Error("initializeWasm() must be awaited first!");
13188 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
13189 return nativeResponseValue;
13191 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
13193 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
13194 if(!isWasmInitialized) {
13195 throw new Error("initializeWasm() must be awaited first!");
13197 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
13198 return nativeResponseValue;
13200 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
13202 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: number): number {
13203 if(!isWasmInitialized) {
13204 throw new Error("initializeWasm() must be awaited first!");
13206 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
13207 return nativeResponseValue;
13209 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
13211 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
13212 if(!isWasmInitialized) {
13213 throw new Error("initializeWasm() must be awaited first!");
13215 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
13216 // debug statements here
13218 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
13220 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
13221 if(!isWasmInitialized) {
13222 throw new Error("initializeWasm() must be awaited first!");
13224 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
13225 return nativeResponseValue;
13227 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
13229 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
13230 if(!isWasmInitialized) {
13231 throw new Error("initializeWasm() must be awaited first!");
13233 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
13234 return nativeResponseValue;
13236 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
13238 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: number): boolean {
13239 if(!isWasmInitialized) {
13240 throw new Error("initializeWasm() must be awaited first!");
13242 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
13243 return nativeResponseValue;
13245 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
13247 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
13248 if(!isWasmInitialized) {
13249 throw new Error("initializeWasm() must be awaited first!");
13251 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
13252 // debug statements here
13254 // uintptr_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
13256 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: number): number {
13257 if(!isWasmInitialized) {
13258 throw new Error("initializeWasm() must be awaited first!");
13260 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
13261 return nativeResponseValue;
13263 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
13265 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
13266 if(!isWasmInitialized) {
13267 throw new Error("initializeWasm() must be awaited first!");
13269 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
13270 return nativeResponseValue;
13272 // uintptr_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
13274 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: number): number {
13275 if(!isWasmInitialized) {
13276 throw new Error("initializeWasm() must be awaited first!");
13278 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
13279 return nativeResponseValue;
13281 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
13283 export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
13284 if(!isWasmInitialized) {
13285 throw new Error("initializeWasm() must be awaited first!");
13287 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
13288 return nativeResponseValue;
13290 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
13292 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: number): number {
13293 if(!isWasmInitialized) {
13294 throw new Error("initializeWasm() must be awaited first!");
13296 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
13297 return nativeResponseValue;
13299 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
13301 export function C2Tuple_PublicKeyTypeZ_free(_res: number): void {
13302 if(!isWasmInitialized) {
13303 throw new Error("initializeWasm() must be awaited first!");
13305 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
13306 // debug statements here
13308 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
13310 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
13311 if(!isWasmInitialized) {
13312 throw new Error("initializeWasm() must be awaited first!");
13314 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
13315 // debug statements here
13317 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
13319 export function COption_NetAddressZ_some(o: number): number {
13320 if(!isWasmInitialized) {
13321 throw new Error("initializeWasm() must be awaited first!");
13323 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
13324 return nativeResponseValue;
13326 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
13328 export function COption_NetAddressZ_none(): number {
13329 if(!isWasmInitialized) {
13330 throw new Error("initializeWasm() must be awaited first!");
13332 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
13333 return nativeResponseValue;
13335 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
13337 export function COption_NetAddressZ_free(_res: number): void {
13338 if(!isWasmInitialized) {
13339 throw new Error("initializeWasm() must be awaited first!");
13341 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
13342 // debug statements here
13344 // uintptr_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
13346 export function COption_NetAddressZ_clone_ptr(arg: number): number {
13347 if(!isWasmInitialized) {
13348 throw new Error("initializeWasm() must be awaited first!");
13350 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
13351 return nativeResponseValue;
13353 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
13355 export function COption_NetAddressZ_clone(orig: number): number {
13356 if(!isWasmInitialized) {
13357 throw new Error("initializeWasm() must be awaited first!");
13359 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
13360 return nativeResponseValue;
13362 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
13364 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): number {
13365 if(!isWasmInitialized) {
13366 throw new Error("initializeWasm() must be awaited first!");
13368 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
13369 return nativeResponseValue;
13371 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
13373 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
13374 if(!isWasmInitialized) {
13375 throw new Error("initializeWasm() must be awaited first!");
13377 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
13378 return nativeResponseValue;
13380 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
13382 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: number): boolean {
13383 if(!isWasmInitialized) {
13384 throw new Error("initializeWasm() must be awaited first!");
13386 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
13387 return nativeResponseValue;
13389 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
13391 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
13392 if(!isWasmInitialized) {
13393 throw new Error("initializeWasm() must be awaited first!");
13395 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
13396 // debug statements here
13398 // uintptr_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
13400 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: number): number {
13401 if(!isWasmInitialized) {
13402 throw new Error("initializeWasm() must be awaited first!");
13404 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
13405 return nativeResponseValue;
13407 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
13409 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
13410 if(!isWasmInitialized) {
13411 throw new Error("initializeWasm() must be awaited first!");
13413 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
13414 return nativeResponseValue;
13416 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
13418 export function CResult_NonePeerHandleErrorZ_ok(): number {
13419 if(!isWasmInitialized) {
13420 throw new Error("initializeWasm() must be awaited first!");
13422 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
13423 return nativeResponseValue;
13425 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
13427 export function CResult_NonePeerHandleErrorZ_err(e: number): number {
13428 if(!isWasmInitialized) {
13429 throw new Error("initializeWasm() must be awaited first!");
13431 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
13432 return nativeResponseValue;
13434 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
13436 export function CResult_NonePeerHandleErrorZ_is_ok(o: number): boolean {
13437 if(!isWasmInitialized) {
13438 throw new Error("initializeWasm() must be awaited first!");
13440 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
13441 return nativeResponseValue;
13443 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
13445 export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
13446 if(!isWasmInitialized) {
13447 throw new Error("initializeWasm() must be awaited first!");
13449 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
13450 // debug statements here
13452 // uintptr_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
13454 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: number): number {
13455 if(!isWasmInitialized) {
13456 throw new Error("initializeWasm() must be awaited first!");
13458 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
13459 return nativeResponseValue;
13461 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
13463 export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
13464 if(!isWasmInitialized) {
13465 throw new Error("initializeWasm() must be awaited first!");
13467 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
13468 return nativeResponseValue;
13470 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
13472 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
13473 if(!isWasmInitialized) {
13474 throw new Error("initializeWasm() must be awaited first!");
13476 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
13477 return nativeResponseValue;
13479 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
13481 export function CResult_boolPeerHandleErrorZ_err(e: number): number {
13482 if(!isWasmInitialized) {
13483 throw new Error("initializeWasm() must be awaited first!");
13485 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
13486 return nativeResponseValue;
13488 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
13490 export function CResult_boolPeerHandleErrorZ_is_ok(o: number): boolean {
13491 if(!isWasmInitialized) {
13492 throw new Error("initializeWasm() must be awaited first!");
13494 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
13495 return nativeResponseValue;
13497 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
13499 export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
13500 if(!isWasmInitialized) {
13501 throw new Error("initializeWasm() must be awaited first!");
13503 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
13504 // debug statements here
13506 // uintptr_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
13508 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: number): number {
13509 if(!isWasmInitialized) {
13510 throw new Error("initializeWasm() must be awaited first!");
13512 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
13513 return nativeResponseValue;
13515 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
13517 export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
13518 if(!isWasmInitialized) {
13519 throw new Error("initializeWasm() must be awaited first!");
13521 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
13522 return nativeResponseValue;
13524 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
13526 export function CResult_NoneErrorZ_ok(): number {
13527 if(!isWasmInitialized) {
13528 throw new Error("initializeWasm() must be awaited first!");
13530 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
13531 return nativeResponseValue;
13533 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
13535 export function CResult_NoneErrorZ_err(e: IOError): number {
13536 if(!isWasmInitialized) {
13537 throw new Error("initializeWasm() must be awaited first!");
13539 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
13540 return nativeResponseValue;
13542 // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
13544 export function CResult_NoneErrorZ_is_ok(o: number): boolean {
13545 if(!isWasmInitialized) {
13546 throw new Error("initializeWasm() must be awaited first!");
13548 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
13549 return nativeResponseValue;
13551 // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
13553 export function CResult_NoneErrorZ_free(_res: number): void {
13554 if(!isWasmInitialized) {
13555 throw new Error("initializeWasm() must be awaited first!");
13557 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
13558 // debug statements here
13560 // uintptr_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
13562 export function CResult_NoneErrorZ_clone_ptr(arg: number): number {
13563 if(!isWasmInitialized) {
13564 throw new Error("initializeWasm() must be awaited first!");
13566 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
13567 return nativeResponseValue;
13569 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
13571 export function CResult_NoneErrorZ_clone(orig: number): number {
13572 if(!isWasmInitialized) {
13573 throw new Error("initializeWasm() must be awaited first!");
13575 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
13576 return nativeResponseValue;
13578 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
13580 export function CResult_NetAddressDecodeErrorZ_ok(o: number): number {
13581 if(!isWasmInitialized) {
13582 throw new Error("initializeWasm() must be awaited first!");
13584 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
13585 return nativeResponseValue;
13587 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
13589 export function CResult_NetAddressDecodeErrorZ_err(e: number): number {
13590 if(!isWasmInitialized) {
13591 throw new Error("initializeWasm() must be awaited first!");
13593 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
13594 return nativeResponseValue;
13596 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
13598 export function CResult_NetAddressDecodeErrorZ_is_ok(o: number): boolean {
13599 if(!isWasmInitialized) {
13600 throw new Error("initializeWasm() must be awaited first!");
13602 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
13603 return nativeResponseValue;
13605 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
13607 export function CResult_NetAddressDecodeErrorZ_free(_res: number): void {
13608 if(!isWasmInitialized) {
13609 throw new Error("initializeWasm() must be awaited first!");
13611 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
13612 // debug statements here
13614 // uintptr_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
13616 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: number): number {
13617 if(!isWasmInitialized) {
13618 throw new Error("initializeWasm() must be awaited first!");
13620 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
13621 return nativeResponseValue;
13623 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
13625 export function CResult_NetAddressDecodeErrorZ_clone(orig: number): number {
13626 if(!isWasmInitialized) {
13627 throw new Error("initializeWasm() must be awaited first!");
13629 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
13630 return nativeResponseValue;
13632 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
13634 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
13635 if(!isWasmInitialized) {
13636 throw new Error("initializeWasm() must be awaited first!");
13638 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
13639 // debug statements here
13641 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
13643 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
13644 if(!isWasmInitialized) {
13645 throw new Error("initializeWasm() must be awaited first!");
13647 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
13648 // debug statements here
13650 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
13652 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
13653 if(!isWasmInitialized) {
13654 throw new Error("initializeWasm() must be awaited first!");
13656 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
13657 // debug statements here
13659 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
13661 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
13662 if(!isWasmInitialized) {
13663 throw new Error("initializeWasm() must be awaited first!");
13665 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
13666 // debug statements here
13668 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
13670 export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
13671 if(!isWasmInitialized) {
13672 throw new Error("initializeWasm() must be awaited first!");
13674 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
13675 return nativeResponseValue;
13677 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
13679 export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
13680 if(!isWasmInitialized) {
13681 throw new Error("initializeWasm() must be awaited first!");
13683 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
13684 return nativeResponseValue;
13686 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
13688 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: number): boolean {
13689 if(!isWasmInitialized) {
13690 throw new Error("initializeWasm() must be awaited first!");
13692 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
13693 return nativeResponseValue;
13695 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
13697 export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
13698 if(!isWasmInitialized) {
13699 throw new Error("initializeWasm() must be awaited first!");
13701 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
13702 // debug statements here
13704 // uintptr_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
13706 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: number): number {
13707 if(!isWasmInitialized) {
13708 throw new Error("initializeWasm() must be awaited first!");
13710 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
13711 return nativeResponseValue;
13713 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
13715 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
13716 if(!isWasmInitialized) {
13717 throw new Error("initializeWasm() must be awaited first!");
13719 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
13720 return nativeResponseValue;
13722 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
13724 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
13725 if(!isWasmInitialized) {
13726 throw new Error("initializeWasm() must be awaited first!");
13728 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
13729 return nativeResponseValue;
13731 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
13733 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
13734 if(!isWasmInitialized) {
13735 throw new Error("initializeWasm() must be awaited first!");
13737 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
13738 return nativeResponseValue;
13740 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
13742 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: number): boolean {
13743 if(!isWasmInitialized) {
13744 throw new Error("initializeWasm() must be awaited first!");
13746 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
13747 return nativeResponseValue;
13749 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
13751 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
13752 if(!isWasmInitialized) {
13753 throw new Error("initializeWasm() must be awaited first!");
13755 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
13756 // debug statements here
13758 // uintptr_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
13760 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: number): number {
13761 if(!isWasmInitialized) {
13762 throw new Error("initializeWasm() must be awaited first!");
13764 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
13765 return nativeResponseValue;
13767 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
13769 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
13770 if(!isWasmInitialized) {
13771 throw new Error("initializeWasm() must be awaited first!");
13773 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
13774 return nativeResponseValue;
13776 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
13778 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
13779 if(!isWasmInitialized) {
13780 throw new Error("initializeWasm() must be awaited first!");
13782 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
13783 return nativeResponseValue;
13785 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
13787 export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
13788 if(!isWasmInitialized) {
13789 throw new Error("initializeWasm() must be awaited first!");
13791 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
13792 return nativeResponseValue;
13794 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
13796 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: number): boolean {
13797 if(!isWasmInitialized) {
13798 throw new Error("initializeWasm() must be awaited first!");
13800 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
13801 return nativeResponseValue;
13803 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
13805 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
13806 if(!isWasmInitialized) {
13807 throw new Error("initializeWasm() must be awaited first!");
13809 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
13810 // debug statements here
13812 // uintptr_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
13814 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: number): number {
13815 if(!isWasmInitialized) {
13816 throw new Error("initializeWasm() must be awaited first!");
13818 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
13819 return nativeResponseValue;
13821 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
13823 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
13824 if(!isWasmInitialized) {
13825 throw new Error("initializeWasm() must be awaited first!");
13827 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
13828 return nativeResponseValue;
13830 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
13832 export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
13833 if(!isWasmInitialized) {
13834 throw new Error("initializeWasm() must be awaited first!");
13836 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
13837 return nativeResponseValue;
13839 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13841 export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
13842 if(!isWasmInitialized) {
13843 throw new Error("initializeWasm() must be awaited first!");
13845 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
13846 return nativeResponseValue;
13848 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
13850 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: number): boolean {
13851 if(!isWasmInitialized) {
13852 throw new Error("initializeWasm() must be awaited first!");
13854 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
13855 return nativeResponseValue;
13857 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
13859 export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
13860 if(!isWasmInitialized) {
13861 throw new Error("initializeWasm() must be awaited first!");
13863 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
13864 // debug statements here
13866 // uintptr_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
13868 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: number): number {
13869 if(!isWasmInitialized) {
13870 throw new Error("initializeWasm() must be awaited first!");
13872 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
13873 return nativeResponseValue;
13875 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
13877 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
13878 if(!isWasmInitialized) {
13879 throw new Error("initializeWasm() must be awaited first!");
13881 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
13882 return nativeResponseValue;
13884 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
13886 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: number): number {
13887 if(!isWasmInitialized) {
13888 throw new Error("initializeWasm() must be awaited first!");
13890 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
13891 return nativeResponseValue;
13893 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
13895 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: number): number {
13896 if(!isWasmInitialized) {
13897 throw new Error("initializeWasm() must be awaited first!");
13899 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
13900 return nativeResponseValue;
13902 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
13904 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: number): boolean {
13905 if(!isWasmInitialized) {
13906 throw new Error("initializeWasm() must be awaited first!");
13908 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
13909 return nativeResponseValue;
13911 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
13913 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
13914 if(!isWasmInitialized) {
13915 throw new Error("initializeWasm() must be awaited first!");
13917 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
13918 // debug statements here
13920 // uintptr_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
13922 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: number): number {
13923 if(!isWasmInitialized) {
13924 throw new Error("initializeWasm() must be awaited first!");
13926 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
13927 return nativeResponseValue;
13929 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
13931 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
13932 if(!isWasmInitialized) {
13933 throw new Error("initializeWasm() must be awaited first!");
13935 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
13936 return nativeResponseValue;
13938 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
13940 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
13941 if(!isWasmInitialized) {
13942 throw new Error("initializeWasm() must be awaited first!");
13944 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
13945 return nativeResponseValue;
13947 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
13949 export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
13950 if(!isWasmInitialized) {
13951 throw new Error("initializeWasm() must be awaited first!");
13953 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
13954 return nativeResponseValue;
13956 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
13958 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: number): boolean {
13959 if(!isWasmInitialized) {
13960 throw new Error("initializeWasm() must be awaited first!");
13962 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
13963 return nativeResponseValue;
13965 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
13967 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
13968 if(!isWasmInitialized) {
13969 throw new Error("initializeWasm() must be awaited first!");
13971 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
13972 // debug statements here
13974 // uintptr_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
13976 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: number): number {
13977 if(!isWasmInitialized) {
13978 throw new Error("initializeWasm() must be awaited first!");
13980 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
13981 return nativeResponseValue;
13983 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
13985 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
13986 if(!isWasmInitialized) {
13987 throw new Error("initializeWasm() must be awaited first!");
13989 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
13990 return nativeResponseValue;
13992 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
13994 export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
13995 if(!isWasmInitialized) {
13996 throw new Error("initializeWasm() must be awaited first!");
13998 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
13999 return nativeResponseValue;
14001 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
14003 export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
14004 if(!isWasmInitialized) {
14005 throw new Error("initializeWasm() must be awaited first!");
14007 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
14008 return nativeResponseValue;
14010 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
14012 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: number): boolean {
14013 if(!isWasmInitialized) {
14014 throw new Error("initializeWasm() must be awaited first!");
14016 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
14017 return nativeResponseValue;
14019 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
14021 export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
14022 if(!isWasmInitialized) {
14023 throw new Error("initializeWasm() must be awaited first!");
14025 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
14026 // debug statements here
14028 // uintptr_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
14030 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: number): number {
14031 if(!isWasmInitialized) {
14032 throw new Error("initializeWasm() must be awaited first!");
14034 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
14035 return nativeResponseValue;
14037 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
14039 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
14040 if(!isWasmInitialized) {
14041 throw new Error("initializeWasm() must be awaited first!");
14043 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
14044 return nativeResponseValue;
14046 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
14048 export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
14049 if(!isWasmInitialized) {
14050 throw new Error("initializeWasm() must be awaited first!");
14052 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
14053 return nativeResponseValue;
14055 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
14057 export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
14058 if(!isWasmInitialized) {
14059 throw new Error("initializeWasm() must be awaited first!");
14061 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
14062 return nativeResponseValue;
14064 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
14066 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: number): boolean {
14067 if(!isWasmInitialized) {
14068 throw new Error("initializeWasm() must be awaited first!");
14070 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
14071 return nativeResponseValue;
14073 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
14075 export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
14076 if(!isWasmInitialized) {
14077 throw new Error("initializeWasm() must be awaited first!");
14079 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
14080 // debug statements here
14082 // uintptr_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
14084 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: number): number {
14085 if(!isWasmInitialized) {
14086 throw new Error("initializeWasm() must be awaited first!");
14088 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
14089 return nativeResponseValue;
14091 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
14093 export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
14094 if(!isWasmInitialized) {
14095 throw new Error("initializeWasm() must be awaited first!");
14097 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
14098 return nativeResponseValue;
14100 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
14102 export function CResult_ChannelReadyDecodeErrorZ_ok(o: number): number {
14103 if(!isWasmInitialized) {
14104 throw new Error("initializeWasm() must be awaited first!");
14106 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
14107 return nativeResponseValue;
14109 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
14111 export function CResult_ChannelReadyDecodeErrorZ_err(e: number): number {
14112 if(!isWasmInitialized) {
14113 throw new Error("initializeWasm() must be awaited first!");
14115 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
14116 return nativeResponseValue;
14118 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
14120 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: number): boolean {
14121 if(!isWasmInitialized) {
14122 throw new Error("initializeWasm() must be awaited first!");
14124 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
14125 return nativeResponseValue;
14127 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
14129 export function CResult_ChannelReadyDecodeErrorZ_free(_res: number): void {
14130 if(!isWasmInitialized) {
14131 throw new Error("initializeWasm() must be awaited first!");
14133 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
14134 // debug statements here
14136 // uintptr_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
14138 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: number): number {
14139 if(!isWasmInitialized) {
14140 throw new Error("initializeWasm() must be awaited first!");
14142 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
14143 return nativeResponseValue;
14145 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
14147 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: number): number {
14148 if(!isWasmInitialized) {
14149 throw new Error("initializeWasm() must be awaited first!");
14151 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
14152 return nativeResponseValue;
14154 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
14156 export function CResult_InitDecodeErrorZ_ok(o: number): number {
14157 if(!isWasmInitialized) {
14158 throw new Error("initializeWasm() must be awaited first!");
14160 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
14161 return nativeResponseValue;
14163 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
14165 export function CResult_InitDecodeErrorZ_err(e: number): number {
14166 if(!isWasmInitialized) {
14167 throw new Error("initializeWasm() must be awaited first!");
14169 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
14170 return nativeResponseValue;
14172 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
14174 export function CResult_InitDecodeErrorZ_is_ok(o: number): boolean {
14175 if(!isWasmInitialized) {
14176 throw new Error("initializeWasm() must be awaited first!");
14178 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
14179 return nativeResponseValue;
14181 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
14183 export function CResult_InitDecodeErrorZ_free(_res: number): void {
14184 if(!isWasmInitialized) {
14185 throw new Error("initializeWasm() must be awaited first!");
14187 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
14188 // debug statements here
14190 // uintptr_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
14192 export function CResult_InitDecodeErrorZ_clone_ptr(arg: number): number {
14193 if(!isWasmInitialized) {
14194 throw new Error("initializeWasm() must be awaited first!");
14196 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
14197 return nativeResponseValue;
14199 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
14201 export function CResult_InitDecodeErrorZ_clone(orig: number): number {
14202 if(!isWasmInitialized) {
14203 throw new Error("initializeWasm() must be awaited first!");
14205 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
14206 return nativeResponseValue;
14208 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
14210 export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
14211 if(!isWasmInitialized) {
14212 throw new Error("initializeWasm() must be awaited first!");
14214 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
14215 return nativeResponseValue;
14217 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
14219 export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
14220 if(!isWasmInitialized) {
14221 throw new Error("initializeWasm() must be awaited first!");
14223 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
14224 return nativeResponseValue;
14226 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
14228 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: number): boolean {
14229 if(!isWasmInitialized) {
14230 throw new Error("initializeWasm() must be awaited first!");
14232 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
14233 return nativeResponseValue;
14235 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
14237 export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
14238 if(!isWasmInitialized) {
14239 throw new Error("initializeWasm() must be awaited first!");
14241 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
14242 // debug statements here
14244 // uintptr_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
14246 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: number): number {
14247 if(!isWasmInitialized) {
14248 throw new Error("initializeWasm() must be awaited first!");
14250 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
14251 return nativeResponseValue;
14253 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
14255 export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
14256 if(!isWasmInitialized) {
14257 throw new Error("initializeWasm() must be awaited first!");
14259 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
14260 return nativeResponseValue;
14262 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
14264 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
14265 if(!isWasmInitialized) {
14266 throw new Error("initializeWasm() must be awaited first!");
14268 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
14269 return nativeResponseValue;
14271 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
14273 export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
14274 if(!isWasmInitialized) {
14275 throw new Error("initializeWasm() must be awaited first!");
14277 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
14278 return nativeResponseValue;
14280 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
14282 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: number): boolean {
14283 if(!isWasmInitialized) {
14284 throw new Error("initializeWasm() must be awaited first!");
14286 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
14287 return nativeResponseValue;
14289 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
14291 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
14292 if(!isWasmInitialized) {
14293 throw new Error("initializeWasm() must be awaited first!");
14295 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
14296 // debug statements here
14298 // uintptr_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
14300 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: number): number {
14301 if(!isWasmInitialized) {
14302 throw new Error("initializeWasm() must be awaited first!");
14304 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
14305 return nativeResponseValue;
14307 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
14309 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
14310 if(!isWasmInitialized) {
14311 throw new Error("initializeWasm() must be awaited first!");
14313 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
14314 return nativeResponseValue;
14316 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
14318 export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
14319 if(!isWasmInitialized) {
14320 throw new Error("initializeWasm() must be awaited first!");
14322 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
14323 return nativeResponseValue;
14325 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
14327 export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
14328 if(!isWasmInitialized) {
14329 throw new Error("initializeWasm() must be awaited first!");
14331 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
14332 return nativeResponseValue;
14334 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
14336 export function CResult_ShutdownDecodeErrorZ_is_ok(o: number): boolean {
14337 if(!isWasmInitialized) {
14338 throw new Error("initializeWasm() must be awaited first!");
14340 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
14341 return nativeResponseValue;
14343 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
14345 export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
14346 if(!isWasmInitialized) {
14347 throw new Error("initializeWasm() must be awaited first!");
14349 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
14350 // debug statements here
14352 // uintptr_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
14354 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: number): number {
14355 if(!isWasmInitialized) {
14356 throw new Error("initializeWasm() must be awaited first!");
14358 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
14359 return nativeResponseValue;
14361 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
14363 export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
14364 if(!isWasmInitialized) {
14365 throw new Error("initializeWasm() must be awaited first!");
14367 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
14368 return nativeResponseValue;
14370 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
14372 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
14373 if(!isWasmInitialized) {
14374 throw new Error("initializeWasm() must be awaited first!");
14376 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
14377 return nativeResponseValue;
14379 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14381 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
14382 if(!isWasmInitialized) {
14383 throw new Error("initializeWasm() must be awaited first!");
14385 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
14386 return nativeResponseValue;
14388 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
14390 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: number): boolean {
14391 if(!isWasmInitialized) {
14392 throw new Error("initializeWasm() must be awaited first!");
14394 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
14395 return nativeResponseValue;
14397 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
14399 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
14400 if(!isWasmInitialized) {
14401 throw new Error("initializeWasm() must be awaited first!");
14403 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
14404 // debug statements here
14406 // uintptr_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
14408 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14409 if(!isWasmInitialized) {
14410 throw new Error("initializeWasm() must be awaited first!");
14412 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
14413 return nativeResponseValue;
14415 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
14417 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
14418 if(!isWasmInitialized) {
14419 throw new Error("initializeWasm() must be awaited first!");
14421 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
14422 return nativeResponseValue;
14424 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
14426 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
14427 if(!isWasmInitialized) {
14428 throw new Error("initializeWasm() must be awaited first!");
14430 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
14431 return nativeResponseValue;
14433 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14435 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
14436 if(!isWasmInitialized) {
14437 throw new Error("initializeWasm() must be awaited first!");
14439 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
14440 return nativeResponseValue;
14442 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
14444 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: number): boolean {
14445 if(!isWasmInitialized) {
14446 throw new Error("initializeWasm() must be awaited first!");
14448 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
14449 return nativeResponseValue;
14451 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
14453 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
14454 if(!isWasmInitialized) {
14455 throw new Error("initializeWasm() must be awaited first!");
14457 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
14458 // debug statements here
14460 // uintptr_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
14462 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14463 if(!isWasmInitialized) {
14464 throw new Error("initializeWasm() must be awaited first!");
14466 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
14467 return nativeResponseValue;
14469 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
14471 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
14472 if(!isWasmInitialized) {
14473 throw new Error("initializeWasm() must be awaited first!");
14475 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
14476 return nativeResponseValue;
14478 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
14480 export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
14481 if(!isWasmInitialized) {
14482 throw new Error("initializeWasm() must be awaited first!");
14484 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
14485 return nativeResponseValue;
14487 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
14489 export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
14490 if(!isWasmInitialized) {
14491 throw new Error("initializeWasm() must be awaited first!");
14493 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
14494 return nativeResponseValue;
14496 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
14498 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: number): boolean {
14499 if(!isWasmInitialized) {
14500 throw new Error("initializeWasm() must be awaited first!");
14502 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
14503 return nativeResponseValue;
14505 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
14507 export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
14508 if(!isWasmInitialized) {
14509 throw new Error("initializeWasm() must be awaited first!");
14511 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
14512 // debug statements here
14514 // uintptr_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
14516 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: number): number {
14517 if(!isWasmInitialized) {
14518 throw new Error("initializeWasm() must be awaited first!");
14520 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
14521 return nativeResponseValue;
14523 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
14525 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
14526 if(!isWasmInitialized) {
14527 throw new Error("initializeWasm() must be awaited first!");
14529 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
14530 return nativeResponseValue;
14532 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
14534 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
14535 if(!isWasmInitialized) {
14536 throw new Error("initializeWasm() must be awaited first!");
14538 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
14539 return nativeResponseValue;
14541 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14543 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
14544 if(!isWasmInitialized) {
14545 throw new Error("initializeWasm() must be awaited first!");
14547 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
14548 return nativeResponseValue;
14550 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
14552 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: number): boolean {
14553 if(!isWasmInitialized) {
14554 throw new Error("initializeWasm() must be awaited first!");
14556 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
14557 return nativeResponseValue;
14559 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
14561 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
14562 if(!isWasmInitialized) {
14563 throw new Error("initializeWasm() must be awaited first!");
14565 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
14566 // debug statements here
14568 // uintptr_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
14570 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14571 if(!isWasmInitialized) {
14572 throw new Error("initializeWasm() must be awaited first!");
14574 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
14575 return nativeResponseValue;
14577 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
14579 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
14580 if(!isWasmInitialized) {
14581 throw new Error("initializeWasm() must be awaited first!");
14583 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
14584 return nativeResponseValue;
14586 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
14588 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
14589 if(!isWasmInitialized) {
14590 throw new Error("initializeWasm() must be awaited first!");
14592 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
14593 return nativeResponseValue;
14595 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14597 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
14598 if(!isWasmInitialized) {
14599 throw new Error("initializeWasm() must be awaited first!");
14601 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
14602 return nativeResponseValue;
14604 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
14606 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: number): boolean {
14607 if(!isWasmInitialized) {
14608 throw new Error("initializeWasm() must be awaited first!");
14610 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
14611 return nativeResponseValue;
14613 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
14615 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
14616 if(!isWasmInitialized) {
14617 throw new Error("initializeWasm() must be awaited first!");
14619 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
14620 // debug statements here
14622 // uintptr_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
14624 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14625 if(!isWasmInitialized) {
14626 throw new Error("initializeWasm() must be awaited first!");
14628 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
14629 return nativeResponseValue;
14631 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
14633 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
14634 if(!isWasmInitialized) {
14635 throw new Error("initializeWasm() must be awaited first!");
14637 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
14638 return nativeResponseValue;
14640 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
14642 export function CResult_PingDecodeErrorZ_ok(o: number): number {
14643 if(!isWasmInitialized) {
14644 throw new Error("initializeWasm() must be awaited first!");
14646 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
14647 return nativeResponseValue;
14649 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
14651 export function CResult_PingDecodeErrorZ_err(e: number): number {
14652 if(!isWasmInitialized) {
14653 throw new Error("initializeWasm() must be awaited first!");
14655 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
14656 return nativeResponseValue;
14658 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
14660 export function CResult_PingDecodeErrorZ_is_ok(o: number): boolean {
14661 if(!isWasmInitialized) {
14662 throw new Error("initializeWasm() must be awaited first!");
14664 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
14665 return nativeResponseValue;
14667 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
14669 export function CResult_PingDecodeErrorZ_free(_res: number): void {
14670 if(!isWasmInitialized) {
14671 throw new Error("initializeWasm() must be awaited first!");
14673 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
14674 // debug statements here
14676 // uintptr_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
14678 export function CResult_PingDecodeErrorZ_clone_ptr(arg: number): number {
14679 if(!isWasmInitialized) {
14680 throw new Error("initializeWasm() must be awaited first!");
14682 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
14683 return nativeResponseValue;
14685 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
14687 export function CResult_PingDecodeErrorZ_clone(orig: number): number {
14688 if(!isWasmInitialized) {
14689 throw new Error("initializeWasm() must be awaited first!");
14691 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
14692 return nativeResponseValue;
14694 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
14696 export function CResult_PongDecodeErrorZ_ok(o: number): number {
14697 if(!isWasmInitialized) {
14698 throw new Error("initializeWasm() must be awaited first!");
14700 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
14701 return nativeResponseValue;
14703 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
14705 export function CResult_PongDecodeErrorZ_err(e: number): number {
14706 if(!isWasmInitialized) {
14707 throw new Error("initializeWasm() must be awaited first!");
14709 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
14710 return nativeResponseValue;
14712 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
14714 export function CResult_PongDecodeErrorZ_is_ok(o: number): boolean {
14715 if(!isWasmInitialized) {
14716 throw new Error("initializeWasm() must be awaited first!");
14718 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
14719 return nativeResponseValue;
14721 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
14723 export function CResult_PongDecodeErrorZ_free(_res: number): void {
14724 if(!isWasmInitialized) {
14725 throw new Error("initializeWasm() must be awaited first!");
14727 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
14728 // debug statements here
14730 // uintptr_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
14732 export function CResult_PongDecodeErrorZ_clone_ptr(arg: number): number {
14733 if(!isWasmInitialized) {
14734 throw new Error("initializeWasm() must be awaited first!");
14736 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
14737 return nativeResponseValue;
14739 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
14741 export function CResult_PongDecodeErrorZ_clone(orig: number): number {
14742 if(!isWasmInitialized) {
14743 throw new Error("initializeWasm() must be awaited first!");
14745 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
14746 return nativeResponseValue;
14748 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
14750 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
14751 if(!isWasmInitialized) {
14752 throw new Error("initializeWasm() must be awaited first!");
14754 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
14755 return nativeResponseValue;
14757 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14759 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
14760 if(!isWasmInitialized) {
14761 throw new Error("initializeWasm() must be awaited first!");
14763 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
14764 return nativeResponseValue;
14766 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14768 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14769 if(!isWasmInitialized) {
14770 throw new Error("initializeWasm() must be awaited first!");
14772 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
14773 return nativeResponseValue;
14775 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
14777 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
14778 if(!isWasmInitialized) {
14779 throw new Error("initializeWasm() must be awaited first!");
14781 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
14782 // debug statements here
14784 // uintptr_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14786 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14787 if(!isWasmInitialized) {
14788 throw new Error("initializeWasm() must be awaited first!");
14790 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14791 return nativeResponseValue;
14793 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14795 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
14796 if(!isWasmInitialized) {
14797 throw new Error("initializeWasm() must be awaited first!");
14799 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
14800 return nativeResponseValue;
14802 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
14804 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
14805 if(!isWasmInitialized) {
14806 throw new Error("initializeWasm() must be awaited first!");
14808 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
14809 return nativeResponseValue;
14811 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14813 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
14814 if(!isWasmInitialized) {
14815 throw new Error("initializeWasm() must be awaited first!");
14817 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
14818 return nativeResponseValue;
14820 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14822 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14823 if(!isWasmInitialized) {
14824 throw new Error("initializeWasm() must be awaited first!");
14826 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
14827 return nativeResponseValue;
14829 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
14831 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
14832 if(!isWasmInitialized) {
14833 throw new Error("initializeWasm() must be awaited first!");
14835 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
14836 // debug statements here
14838 // uintptr_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14840 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14841 if(!isWasmInitialized) {
14842 throw new Error("initializeWasm() must be awaited first!");
14844 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14845 return nativeResponseValue;
14847 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14849 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
14850 if(!isWasmInitialized) {
14851 throw new Error("initializeWasm() must be awaited first!");
14853 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
14854 return nativeResponseValue;
14856 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
14858 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
14859 if(!isWasmInitialized) {
14860 throw new Error("initializeWasm() must be awaited first!");
14862 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
14863 return nativeResponseValue;
14865 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14867 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
14868 if(!isWasmInitialized) {
14869 throw new Error("initializeWasm() must be awaited first!");
14871 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
14872 return nativeResponseValue;
14874 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14876 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14877 if(!isWasmInitialized) {
14878 throw new Error("initializeWasm() must be awaited first!");
14880 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
14881 return nativeResponseValue;
14883 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
14885 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
14886 if(!isWasmInitialized) {
14887 throw new Error("initializeWasm() must be awaited first!");
14889 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
14890 // debug statements here
14892 // uintptr_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14894 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14895 if(!isWasmInitialized) {
14896 throw new Error("initializeWasm() must be awaited first!");
14898 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
14899 return nativeResponseValue;
14901 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14903 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
14904 if(!isWasmInitialized) {
14905 throw new Error("initializeWasm() must be awaited first!");
14907 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
14908 return nativeResponseValue;
14910 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
14912 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
14913 if(!isWasmInitialized) {
14914 throw new Error("initializeWasm() must be awaited first!");
14916 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
14917 return nativeResponseValue;
14919 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14921 export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
14922 if(!isWasmInitialized) {
14923 throw new Error("initializeWasm() must be awaited first!");
14925 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
14926 return nativeResponseValue;
14928 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14930 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14931 if(!isWasmInitialized) {
14932 throw new Error("initializeWasm() must be awaited first!");
14934 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
14935 return nativeResponseValue;
14937 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
14939 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
14940 if(!isWasmInitialized) {
14941 throw new Error("initializeWasm() must be awaited first!");
14943 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
14944 // debug statements here
14946 // uintptr_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14948 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14949 if(!isWasmInitialized) {
14950 throw new Error("initializeWasm() must be awaited first!");
14952 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
14953 return nativeResponseValue;
14955 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14957 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
14958 if(!isWasmInitialized) {
14959 throw new Error("initializeWasm() must be awaited first!");
14961 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
14962 return nativeResponseValue;
14964 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
14966 export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
14967 if(!isWasmInitialized) {
14968 throw new Error("initializeWasm() must be awaited first!");
14970 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
14971 return nativeResponseValue;
14973 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
14975 export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
14976 if(!isWasmInitialized) {
14977 throw new Error("initializeWasm() must be awaited first!");
14979 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
14980 return nativeResponseValue;
14982 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
14984 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: number): boolean {
14985 if(!isWasmInitialized) {
14986 throw new Error("initializeWasm() must be awaited first!");
14988 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
14989 return nativeResponseValue;
14991 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
14993 export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
14994 if(!isWasmInitialized) {
14995 throw new Error("initializeWasm() must be awaited first!");
14997 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
14998 // debug statements here
15000 // uintptr_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
15002 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: number): number {
15003 if(!isWasmInitialized) {
15004 throw new Error("initializeWasm() must be awaited first!");
15006 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
15007 return nativeResponseValue;
15009 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
15011 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
15012 if(!isWasmInitialized) {
15013 throw new Error("initializeWasm() must be awaited first!");
15015 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
15016 return nativeResponseValue;
15018 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
15020 export function CResult_WarningMessageDecodeErrorZ_ok(o: number): number {
15021 if(!isWasmInitialized) {
15022 throw new Error("initializeWasm() must be awaited first!");
15024 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
15025 return nativeResponseValue;
15027 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
15029 export function CResult_WarningMessageDecodeErrorZ_err(e: number): number {
15030 if(!isWasmInitialized) {
15031 throw new Error("initializeWasm() must be awaited first!");
15033 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
15034 return nativeResponseValue;
15036 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
15038 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: number): boolean {
15039 if(!isWasmInitialized) {
15040 throw new Error("initializeWasm() must be awaited first!");
15042 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
15043 return nativeResponseValue;
15045 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
15047 export function CResult_WarningMessageDecodeErrorZ_free(_res: number): void {
15048 if(!isWasmInitialized) {
15049 throw new Error("initializeWasm() must be awaited first!");
15051 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
15052 // debug statements here
15054 // uintptr_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
15056 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: number): number {
15057 if(!isWasmInitialized) {
15058 throw new Error("initializeWasm() must be awaited first!");
15060 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
15061 return nativeResponseValue;
15063 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
15065 export function CResult_WarningMessageDecodeErrorZ_clone(orig: number): number {
15066 if(!isWasmInitialized) {
15067 throw new Error("initializeWasm() must be awaited first!");
15069 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
15070 return nativeResponseValue;
15072 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
15074 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
15075 if(!isWasmInitialized) {
15076 throw new Error("initializeWasm() must be awaited first!");
15078 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
15079 return nativeResponseValue;
15081 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
15083 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
15084 if(!isWasmInitialized) {
15085 throw new Error("initializeWasm() must be awaited first!");
15087 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
15088 return nativeResponseValue;
15090 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
15092 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
15093 if(!isWasmInitialized) {
15094 throw new Error("initializeWasm() must be awaited first!");
15096 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
15097 return nativeResponseValue;
15099 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
15101 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
15102 if(!isWasmInitialized) {
15103 throw new Error("initializeWasm() must be awaited first!");
15105 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
15106 // debug statements here
15108 // uintptr_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
15110 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
15111 if(!isWasmInitialized) {
15112 throw new Error("initializeWasm() must be awaited first!");
15114 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
15115 return nativeResponseValue;
15117 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
15119 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
15120 if(!isWasmInitialized) {
15121 throw new Error("initializeWasm() must be awaited first!");
15123 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
15124 return nativeResponseValue;
15126 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
15128 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
15129 if(!isWasmInitialized) {
15130 throw new Error("initializeWasm() must be awaited first!");
15132 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
15133 return nativeResponseValue;
15135 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
15137 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
15138 if(!isWasmInitialized) {
15139 throw new Error("initializeWasm() must be awaited first!");
15141 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
15142 return nativeResponseValue;
15144 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
15146 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
15147 if(!isWasmInitialized) {
15148 throw new Error("initializeWasm() must be awaited first!");
15150 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
15151 return nativeResponseValue;
15153 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
15155 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
15156 if(!isWasmInitialized) {
15157 throw new Error("initializeWasm() must be awaited first!");
15159 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
15160 // debug statements here
15162 // uintptr_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
15164 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
15165 if(!isWasmInitialized) {
15166 throw new Error("initializeWasm() must be awaited first!");
15168 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
15169 return nativeResponseValue;
15171 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
15173 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
15174 if(!isWasmInitialized) {
15175 throw new Error("initializeWasm() must be awaited first!");
15177 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
15178 return nativeResponseValue;
15180 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
15182 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
15183 if(!isWasmInitialized) {
15184 throw new Error("initializeWasm() must be awaited first!");
15186 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
15187 return nativeResponseValue;
15189 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
15191 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
15192 if(!isWasmInitialized) {
15193 throw new Error("initializeWasm() must be awaited first!");
15195 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
15196 return nativeResponseValue;
15198 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
15200 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: number): boolean {
15201 if(!isWasmInitialized) {
15202 throw new Error("initializeWasm() must be awaited first!");
15204 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
15205 return nativeResponseValue;
15207 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
15209 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
15210 if(!isWasmInitialized) {
15211 throw new Error("initializeWasm() must be awaited first!");
15213 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
15214 // debug statements here
15216 // uintptr_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
15218 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: number): number {
15219 if(!isWasmInitialized) {
15220 throw new Error("initializeWasm() must be awaited first!");
15222 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
15223 return nativeResponseValue;
15225 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
15227 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
15228 if(!isWasmInitialized) {
15229 throw new Error("initializeWasm() must be awaited first!");
15231 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
15232 return nativeResponseValue;
15234 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
15236 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
15237 if(!isWasmInitialized) {
15238 throw new Error("initializeWasm() must be awaited first!");
15240 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
15241 return nativeResponseValue;
15243 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
15245 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
15246 if(!isWasmInitialized) {
15247 throw new Error("initializeWasm() must be awaited first!");
15249 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
15250 return nativeResponseValue;
15252 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
15254 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: number): boolean {
15255 if(!isWasmInitialized) {
15256 throw new Error("initializeWasm() must be awaited first!");
15258 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
15259 return nativeResponseValue;
15261 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
15263 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
15264 if(!isWasmInitialized) {
15265 throw new Error("initializeWasm() must be awaited first!");
15267 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
15268 // debug statements here
15270 // uintptr_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
15272 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: number): number {
15273 if(!isWasmInitialized) {
15274 throw new Error("initializeWasm() must be awaited first!");
15276 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
15277 return nativeResponseValue;
15279 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
15281 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
15282 if(!isWasmInitialized) {
15283 throw new Error("initializeWasm() must be awaited first!");
15285 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
15286 return nativeResponseValue;
15288 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
15290 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
15291 if(!isWasmInitialized) {
15292 throw new Error("initializeWasm() must be awaited first!");
15294 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
15295 return nativeResponseValue;
15297 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
15299 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
15300 if(!isWasmInitialized) {
15301 throw new Error("initializeWasm() must be awaited first!");
15303 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
15304 return nativeResponseValue;
15306 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
15308 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
15309 if(!isWasmInitialized) {
15310 throw new Error("initializeWasm() must be awaited first!");
15312 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
15313 return nativeResponseValue;
15315 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
15317 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
15318 if(!isWasmInitialized) {
15319 throw new Error("initializeWasm() must be awaited first!");
15321 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
15322 // debug statements here
15324 // uintptr_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
15326 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
15327 if(!isWasmInitialized) {
15328 throw new Error("initializeWasm() must be awaited first!");
15330 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
15331 return nativeResponseValue;
15333 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
15335 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
15336 if(!isWasmInitialized) {
15337 throw new Error("initializeWasm() must be awaited first!");
15339 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
15340 return nativeResponseValue;
15342 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
15344 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
15345 if(!isWasmInitialized) {
15346 throw new Error("initializeWasm() must be awaited first!");
15348 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
15349 return nativeResponseValue;
15351 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
15353 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
15354 if(!isWasmInitialized) {
15355 throw new Error("initializeWasm() must be awaited first!");
15357 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
15358 return nativeResponseValue;
15360 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
15362 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
15363 if(!isWasmInitialized) {
15364 throw new Error("initializeWasm() must be awaited first!");
15366 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
15367 return nativeResponseValue;
15369 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
15371 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
15372 if(!isWasmInitialized) {
15373 throw new Error("initializeWasm() must be awaited first!");
15375 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
15376 // debug statements here
15378 // uintptr_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
15380 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
15381 if(!isWasmInitialized) {
15382 throw new Error("initializeWasm() must be awaited first!");
15384 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
15385 return nativeResponseValue;
15387 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
15389 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
15390 if(!isWasmInitialized) {
15391 throw new Error("initializeWasm() must be awaited first!");
15393 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
15394 return nativeResponseValue;
15396 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
15398 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
15399 if(!isWasmInitialized) {
15400 throw new Error("initializeWasm() must be awaited first!");
15402 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
15403 return nativeResponseValue;
15405 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
15407 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
15408 if(!isWasmInitialized) {
15409 throw new Error("initializeWasm() must be awaited first!");
15411 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
15412 return nativeResponseValue;
15414 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
15416 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: number): boolean {
15417 if(!isWasmInitialized) {
15418 throw new Error("initializeWasm() must be awaited first!");
15420 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
15421 return nativeResponseValue;
15423 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
15425 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
15426 if(!isWasmInitialized) {
15427 throw new Error("initializeWasm() must be awaited first!");
15429 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
15430 // debug statements here
15432 // uintptr_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
15434 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: number): number {
15435 if(!isWasmInitialized) {
15436 throw new Error("initializeWasm() must be awaited first!");
15438 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
15439 return nativeResponseValue;
15441 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
15443 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
15444 if(!isWasmInitialized) {
15445 throw new Error("initializeWasm() must be awaited first!");
15447 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
15448 return nativeResponseValue;
15450 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
15452 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: number): number {
15453 if(!isWasmInitialized) {
15454 throw new Error("initializeWasm() must be awaited first!");
15456 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
15457 return nativeResponseValue;
15459 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
15461 export function CResult_InvoiceSignOrCreationErrorZ_err(e: number): number {
15462 if(!isWasmInitialized) {
15463 throw new Error("initializeWasm() must be awaited first!");
15465 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
15466 return nativeResponseValue;
15468 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
15470 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: number): boolean {
15471 if(!isWasmInitialized) {
15472 throw new Error("initializeWasm() must be awaited first!");
15474 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
15475 return nativeResponseValue;
15477 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
15479 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: number): void {
15480 if(!isWasmInitialized) {
15481 throw new Error("initializeWasm() must be awaited first!");
15483 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
15484 // debug statements here
15486 // uintptr_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
15488 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: number): number {
15489 if(!isWasmInitialized) {
15490 throw new Error("initializeWasm() must be awaited first!");
15492 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
15493 return nativeResponseValue;
15495 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
15497 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: number): number {
15498 if(!isWasmInitialized) {
15499 throw new Error("initializeWasm() must be awaited first!");
15501 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
15502 return nativeResponseValue;
15504 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
15506 export function COption_FilterZ_some(o: number): number {
15507 if(!isWasmInitialized) {
15508 throw new Error("initializeWasm() must be awaited first!");
15510 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
15511 return nativeResponseValue;
15513 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
15515 export function COption_FilterZ_none(): number {
15516 if(!isWasmInitialized) {
15517 throw new Error("initializeWasm() must be awaited first!");
15519 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
15520 return nativeResponseValue;
15522 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
15524 export function COption_FilterZ_free(_res: number): void {
15525 if(!isWasmInitialized) {
15526 throw new Error("initializeWasm() must be awaited first!");
15528 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
15529 // debug statements here
15531 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
15533 export function CResult_LockedChannelMonitorNoneZ_ok(o: number): number {
15534 if(!isWasmInitialized) {
15535 throw new Error("initializeWasm() must be awaited first!");
15537 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
15538 return nativeResponseValue;
15540 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
15542 export function CResult_LockedChannelMonitorNoneZ_err(): number {
15543 if(!isWasmInitialized) {
15544 throw new Error("initializeWasm() must be awaited first!");
15546 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
15547 return nativeResponseValue;
15549 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
15551 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: number): boolean {
15552 if(!isWasmInitialized) {
15553 throw new Error("initializeWasm() must be awaited first!");
15555 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
15556 return nativeResponseValue;
15558 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
15560 export function CResult_LockedChannelMonitorNoneZ_free(_res: number): void {
15561 if(!isWasmInitialized) {
15562 throw new Error("initializeWasm() must be awaited first!");
15564 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
15565 // debug statements here
15567 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
15569 export function CVec_OutPointZ_free(_res: number): void {
15570 if(!isWasmInitialized) {
15571 throw new Error("initializeWasm() must be awaited first!");
15573 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
15574 // debug statements here
15576 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
15578 export function PaymentPurpose_free(this_ptr: number): void {
15579 if(!isWasmInitialized) {
15580 throw new Error("initializeWasm() must be awaited first!");
15582 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
15583 // debug statements here
15585 // uintptr_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
15587 export function PaymentPurpose_clone_ptr(arg: number): number {
15588 if(!isWasmInitialized) {
15589 throw new Error("initializeWasm() must be awaited first!");
15591 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
15592 return nativeResponseValue;
15594 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
15596 export function PaymentPurpose_clone(orig: number): number {
15597 if(!isWasmInitialized) {
15598 throw new Error("initializeWasm() must be awaited first!");
15600 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
15601 return nativeResponseValue;
15603 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
15605 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): number {
15606 if(!isWasmInitialized) {
15607 throw new Error("initializeWasm() must be awaited first!");
15609 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
15610 return nativeResponseValue;
15612 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
15614 export function PaymentPurpose_spontaneous_payment(a: number): number {
15615 if(!isWasmInitialized) {
15616 throw new Error("initializeWasm() must be awaited first!");
15618 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
15619 return nativeResponseValue;
15621 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
15623 export function PaymentPurpose_write(obj: number): number {
15624 if(!isWasmInitialized) {
15625 throw new Error("initializeWasm() must be awaited first!");
15627 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
15628 return nativeResponseValue;
15630 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
15632 export function PaymentPurpose_read(ser: number): number {
15633 if(!isWasmInitialized) {
15634 throw new Error("initializeWasm() must be awaited first!");
15636 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
15637 return nativeResponseValue;
15639 // void ClosureReason_free(struct LDKClosureReason this_ptr);
15641 export function ClosureReason_free(this_ptr: number): void {
15642 if(!isWasmInitialized) {
15643 throw new Error("initializeWasm() must be awaited first!");
15645 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
15646 // debug statements here
15648 // uintptr_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
15650 export function ClosureReason_clone_ptr(arg: number): number {
15651 if(!isWasmInitialized) {
15652 throw new Error("initializeWasm() must be awaited first!");
15654 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
15655 return nativeResponseValue;
15657 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
15659 export function ClosureReason_clone(orig: number): number {
15660 if(!isWasmInitialized) {
15661 throw new Error("initializeWasm() must be awaited first!");
15663 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
15664 return nativeResponseValue;
15666 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
15668 export function ClosureReason_counterparty_force_closed(peer_msg: number): number {
15669 if(!isWasmInitialized) {
15670 throw new Error("initializeWasm() must be awaited first!");
15672 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
15673 return nativeResponseValue;
15675 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
15677 export function ClosureReason_holder_force_closed(): number {
15678 if(!isWasmInitialized) {
15679 throw new Error("initializeWasm() must be awaited first!");
15681 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
15682 return nativeResponseValue;
15684 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
15686 export function ClosureReason_cooperative_closure(): number {
15687 if(!isWasmInitialized) {
15688 throw new Error("initializeWasm() must be awaited first!");
15690 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
15691 return nativeResponseValue;
15693 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
15695 export function ClosureReason_commitment_tx_confirmed(): number {
15696 if(!isWasmInitialized) {
15697 throw new Error("initializeWasm() must be awaited first!");
15699 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
15700 return nativeResponseValue;
15702 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
15704 export function ClosureReason_funding_timed_out(): number {
15705 if(!isWasmInitialized) {
15706 throw new Error("initializeWasm() must be awaited first!");
15708 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
15709 return nativeResponseValue;
15711 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
15713 export function ClosureReason_processing_error(err: number): number {
15714 if(!isWasmInitialized) {
15715 throw new Error("initializeWasm() must be awaited first!");
15717 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
15718 return nativeResponseValue;
15720 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
15722 export function ClosureReason_disconnected_peer(): number {
15723 if(!isWasmInitialized) {
15724 throw new Error("initializeWasm() must be awaited first!");
15726 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
15727 return nativeResponseValue;
15729 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
15731 export function ClosureReason_outdated_channel_manager(): number {
15732 if(!isWasmInitialized) {
15733 throw new Error("initializeWasm() must be awaited first!");
15735 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
15736 return nativeResponseValue;
15738 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
15740 export function ClosureReason_write(obj: number): number {
15741 if(!isWasmInitialized) {
15742 throw new Error("initializeWasm() must be awaited first!");
15744 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
15745 return nativeResponseValue;
15747 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
15749 export function ClosureReason_read(ser: number): number {
15750 if(!isWasmInitialized) {
15751 throw new Error("initializeWasm() must be awaited first!");
15753 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
15754 return nativeResponseValue;
15756 // void HTLCDestination_free(struct LDKHTLCDestination this_ptr);
15758 export function HTLCDestination_free(this_ptr: number): void {
15759 if(!isWasmInitialized) {
15760 throw new Error("initializeWasm() must be awaited first!");
15762 const nativeResponseValue = wasm.TS_HTLCDestination_free(this_ptr);
15763 // debug statements here
15765 // uintptr_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg);
15767 export function HTLCDestination_clone_ptr(arg: number): number {
15768 if(!isWasmInitialized) {
15769 throw new Error("initializeWasm() must be awaited first!");
15771 const nativeResponseValue = wasm.TS_HTLCDestination_clone_ptr(arg);
15772 return nativeResponseValue;
15774 // struct LDKHTLCDestination HTLCDestination_clone(const struct LDKHTLCDestination *NONNULL_PTR orig);
15776 export function HTLCDestination_clone(orig: number): number {
15777 if(!isWasmInitialized) {
15778 throw new Error("initializeWasm() must be awaited first!");
15780 const nativeResponseValue = wasm.TS_HTLCDestination_clone(orig);
15781 return nativeResponseValue;
15783 // struct LDKHTLCDestination HTLCDestination_next_hop_channel(struct LDKPublicKey node_id, struct LDKThirtyTwoBytes channel_id);
15785 export function HTLCDestination_next_hop_channel(node_id: number, channel_id: number): number {
15786 if(!isWasmInitialized) {
15787 throw new Error("initializeWasm() must be awaited first!");
15789 const nativeResponseValue = wasm.TS_HTLCDestination_next_hop_channel(node_id, channel_id);
15790 return nativeResponseValue;
15792 // struct LDKHTLCDestination HTLCDestination_unknown_next_hop(uint64_t requested_forward_scid);
15794 export function HTLCDestination_unknown_next_hop(requested_forward_scid: bigint): number {
15795 if(!isWasmInitialized) {
15796 throw new Error("initializeWasm() must be awaited first!");
15798 const nativeResponseValue = wasm.TS_HTLCDestination_unknown_next_hop(requested_forward_scid);
15799 return nativeResponseValue;
15801 // struct LDKHTLCDestination HTLCDestination_failed_payment(struct LDKThirtyTwoBytes payment_hash);
15803 export function HTLCDestination_failed_payment(payment_hash: number): number {
15804 if(!isWasmInitialized) {
15805 throw new Error("initializeWasm() must be awaited first!");
15807 const nativeResponseValue = wasm.TS_HTLCDestination_failed_payment(payment_hash);
15808 return nativeResponseValue;
15810 // struct LDKCVec_u8Z HTLCDestination_write(const struct LDKHTLCDestination *NONNULL_PTR obj);
15812 export function HTLCDestination_write(obj: number): number {
15813 if(!isWasmInitialized) {
15814 throw new Error("initializeWasm() must be awaited first!");
15816 const nativeResponseValue = wasm.TS_HTLCDestination_write(obj);
15817 return nativeResponseValue;
15819 // struct LDKCResult_COption_HTLCDestinationZDecodeErrorZ HTLCDestination_read(struct LDKu8slice ser);
15821 export function HTLCDestination_read(ser: number): number {
15822 if(!isWasmInitialized) {
15823 throw new Error("initializeWasm() must be awaited first!");
15825 const nativeResponseValue = wasm.TS_HTLCDestination_read(ser);
15826 return nativeResponseValue;
15828 // void Event_free(struct LDKEvent this_ptr);
15830 export function Event_free(this_ptr: number): void {
15831 if(!isWasmInitialized) {
15832 throw new Error("initializeWasm() must be awaited first!");
15834 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
15835 // debug statements here
15837 // uintptr_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
15839 export function Event_clone_ptr(arg: number): number {
15840 if(!isWasmInitialized) {
15841 throw new Error("initializeWasm() must be awaited first!");
15843 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
15844 return nativeResponseValue;
15846 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
15848 export function Event_clone(orig: number): number {
15849 if(!isWasmInitialized) {
15850 throw new Error("initializeWasm() must be awaited first!");
15852 const nativeResponseValue = wasm.TS_Event_clone(orig);
15853 return nativeResponseValue;
15855 // 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);
15857 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 {
15858 if(!isWasmInitialized) {
15859 throw new Error("initializeWasm() must be awaited first!");
15861 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
15862 return nativeResponseValue;
15864 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15866 export function Event_payment_received(payment_hash: number, amount_msat: bigint, purpose: number): number {
15867 if(!isWasmInitialized) {
15868 throw new Error("initializeWasm() must be awaited first!");
15870 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amount_msat, purpose);
15871 return nativeResponseValue;
15873 // struct LDKEvent Event_payment_claimed(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15875 export function Event_payment_claimed(payment_hash: number, amount_msat: bigint, purpose: number): number {
15876 if(!isWasmInitialized) {
15877 throw new Error("initializeWasm() must be awaited first!");
15879 const nativeResponseValue = wasm.TS_Event_payment_claimed(payment_hash, amount_msat, purpose);
15880 return nativeResponseValue;
15882 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
15884 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: number): number {
15885 if(!isWasmInitialized) {
15886 throw new Error("initializeWasm() must be awaited first!");
15888 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
15889 return nativeResponseValue;
15891 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
15893 export function Event_payment_failed(payment_id: number, payment_hash: number): number {
15894 if(!isWasmInitialized) {
15895 throw new Error("initializeWasm() must be awaited first!");
15897 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
15898 return nativeResponseValue;
15900 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
15902 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): number {
15903 if(!isWasmInitialized) {
15904 throw new Error("initializeWasm() must be awaited first!");
15906 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
15907 return nativeResponseValue;
15909 // 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);
15911 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 {
15912 if(!isWasmInitialized) {
15913 throw new Error("initializeWasm() must be awaited first!");
15915 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);
15916 return nativeResponseValue;
15918 // struct LDKEvent Event_probe_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
15920 export function Event_probe_successful(payment_id: number, payment_hash: number, path: number): number {
15921 if(!isWasmInitialized) {
15922 throw new Error("initializeWasm() must be awaited first!");
15924 const nativeResponseValue = wasm.TS_Event_probe_successful(payment_id, payment_hash, path);
15925 return nativeResponseValue;
15927 // struct LDKEvent Event_probe_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path, struct LDKCOption_u64Z short_channel_id);
15929 export function Event_probe_failed(payment_id: number, payment_hash: number, path: number, short_channel_id: number): number {
15930 if(!isWasmInitialized) {
15931 throw new Error("initializeWasm() must be awaited first!");
15933 const nativeResponseValue = wasm.TS_Event_probe_failed(payment_id, payment_hash, path, short_channel_id);
15934 return nativeResponseValue;
15936 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
15938 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): number {
15939 if(!isWasmInitialized) {
15940 throw new Error("initializeWasm() must be awaited first!");
15942 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
15943 return nativeResponseValue;
15945 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
15947 export function Event_spendable_outputs(outputs: number): number {
15948 if(!isWasmInitialized) {
15949 throw new Error("initializeWasm() must be awaited first!");
15951 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
15952 return nativeResponseValue;
15954 // 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);
15956 export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: number, claim_from_onchain_tx: boolean): number {
15957 if(!isWasmInitialized) {
15958 throw new Error("initializeWasm() must be awaited first!");
15960 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx);
15961 return nativeResponseValue;
15963 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
15965 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: number): number {
15966 if(!isWasmInitialized) {
15967 throw new Error("initializeWasm() must be awaited first!");
15969 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
15970 return nativeResponseValue;
15972 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
15974 export function Event_discard_funding(channel_id: number, transaction: number): number {
15975 if(!isWasmInitialized) {
15976 throw new Error("initializeWasm() must be awaited first!");
15978 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
15979 return nativeResponseValue;
15981 // 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);
15983 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: number): number {
15984 if(!isWasmInitialized) {
15985 throw new Error("initializeWasm() must be awaited first!");
15987 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
15988 return nativeResponseValue;
15990 // struct LDKEvent Event_htlchandling_failed(struct LDKThirtyTwoBytes prev_channel_id, struct LDKHTLCDestination failed_next_destination);
15992 export function Event_htlchandling_failed(prev_channel_id: number, failed_next_destination: number): number {
15993 if(!isWasmInitialized) {
15994 throw new Error("initializeWasm() must be awaited first!");
15996 const nativeResponseValue = wasm.TS_Event_htlchandling_failed(prev_channel_id, failed_next_destination);
15997 return nativeResponseValue;
15999 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
16001 export function Event_write(obj: number): number {
16002 if(!isWasmInitialized) {
16003 throw new Error("initializeWasm() must be awaited first!");
16005 const nativeResponseValue = wasm.TS_Event_write(obj);
16006 return nativeResponseValue;
16008 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
16010 export function Event_read(ser: number): number {
16011 if(!isWasmInitialized) {
16012 throw new Error("initializeWasm() must be awaited first!");
16014 const nativeResponseValue = wasm.TS_Event_read(ser);
16015 return nativeResponseValue;
16017 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
16019 export function MessageSendEvent_free(this_ptr: number): void {
16020 if(!isWasmInitialized) {
16021 throw new Error("initializeWasm() must be awaited first!");
16023 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
16024 // debug statements here
16026 // uintptr_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
16028 export function MessageSendEvent_clone_ptr(arg: number): number {
16029 if(!isWasmInitialized) {
16030 throw new Error("initializeWasm() must be awaited first!");
16032 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
16033 return nativeResponseValue;
16035 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
16037 export function MessageSendEvent_clone(orig: number): number {
16038 if(!isWasmInitialized) {
16039 throw new Error("initializeWasm() must be awaited first!");
16041 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
16042 return nativeResponseValue;
16044 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
16046 export function MessageSendEvent_send_accept_channel(node_id: number, msg: number): number {
16047 if(!isWasmInitialized) {
16048 throw new Error("initializeWasm() must be awaited first!");
16050 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
16051 return nativeResponseValue;
16053 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
16055 export function MessageSendEvent_send_open_channel(node_id: number, msg: number): number {
16056 if(!isWasmInitialized) {
16057 throw new Error("initializeWasm() must be awaited first!");
16059 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
16060 return nativeResponseValue;
16062 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
16064 export function MessageSendEvent_send_funding_created(node_id: number, msg: number): number {
16065 if(!isWasmInitialized) {
16066 throw new Error("initializeWasm() must be awaited first!");
16068 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
16069 return nativeResponseValue;
16071 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
16073 export function MessageSendEvent_send_funding_signed(node_id: number, msg: number): number {
16074 if(!isWasmInitialized) {
16075 throw new Error("initializeWasm() must be awaited first!");
16077 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
16078 return nativeResponseValue;
16080 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
16082 export function MessageSendEvent_send_channel_ready(node_id: number, msg: number): number {
16083 if(!isWasmInitialized) {
16084 throw new Error("initializeWasm() must be awaited first!");
16086 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
16087 return nativeResponseValue;
16089 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
16091 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: number): number {
16092 if(!isWasmInitialized) {
16093 throw new Error("initializeWasm() must be awaited first!");
16095 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
16096 return nativeResponseValue;
16098 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
16100 export function MessageSendEvent_update_htlcs(node_id: number, updates: number): number {
16101 if(!isWasmInitialized) {
16102 throw new Error("initializeWasm() must be awaited first!");
16104 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
16105 return nativeResponseValue;
16107 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
16109 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: number): number {
16110 if(!isWasmInitialized) {
16111 throw new Error("initializeWasm() must be awaited first!");
16113 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
16114 return nativeResponseValue;
16116 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
16118 export function MessageSendEvent_send_closing_signed(node_id: number, msg: number): number {
16119 if(!isWasmInitialized) {
16120 throw new Error("initializeWasm() must be awaited first!");
16122 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
16123 return nativeResponseValue;
16125 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
16127 export function MessageSendEvent_send_shutdown(node_id: number, msg: number): number {
16128 if(!isWasmInitialized) {
16129 throw new Error("initializeWasm() must be awaited first!");
16131 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
16132 return nativeResponseValue;
16134 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
16136 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: number): number {
16137 if(!isWasmInitialized) {
16138 throw new Error("initializeWasm() must be awaited first!");
16140 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
16141 return nativeResponseValue;
16143 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
16145 export function MessageSendEvent_broadcast_channel_announcement(msg: number, update_msg: number): number {
16146 if(!isWasmInitialized) {
16147 throw new Error("initializeWasm() must be awaited first!");
16149 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
16150 return nativeResponseValue;
16152 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
16154 export function MessageSendEvent_broadcast_node_announcement(msg: number): number {
16155 if(!isWasmInitialized) {
16156 throw new Error("initializeWasm() must be awaited first!");
16158 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
16159 return nativeResponseValue;
16161 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
16163 export function MessageSendEvent_broadcast_channel_update(msg: number): number {
16164 if(!isWasmInitialized) {
16165 throw new Error("initializeWasm() must be awaited first!");
16167 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
16168 return nativeResponseValue;
16170 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
16172 export function MessageSendEvent_send_channel_update(node_id: number, msg: number): number {
16173 if(!isWasmInitialized) {
16174 throw new Error("initializeWasm() must be awaited first!");
16176 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
16177 return nativeResponseValue;
16179 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
16181 export function MessageSendEvent_handle_error(node_id: number, action: number): number {
16182 if(!isWasmInitialized) {
16183 throw new Error("initializeWasm() must be awaited first!");
16185 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
16186 return nativeResponseValue;
16188 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
16190 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: number): number {
16191 if(!isWasmInitialized) {
16192 throw new Error("initializeWasm() must be awaited first!");
16194 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
16195 return nativeResponseValue;
16197 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
16199 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: number): number {
16200 if(!isWasmInitialized) {
16201 throw new Error("initializeWasm() must be awaited first!");
16203 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
16204 return nativeResponseValue;
16206 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
16208 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: number): number {
16209 if(!isWasmInitialized) {
16210 throw new Error("initializeWasm() must be awaited first!");
16212 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
16213 return nativeResponseValue;
16215 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
16217 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: number): number {
16218 if(!isWasmInitialized) {
16219 throw new Error("initializeWasm() must be awaited first!");
16221 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
16222 return nativeResponseValue;
16224 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
16226 export function MessageSendEventsProvider_free(this_ptr: number): void {
16227 if(!isWasmInitialized) {
16228 throw new Error("initializeWasm() must be awaited first!");
16230 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
16231 // debug statements here
16233 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
16235 export function EventsProvider_free(this_ptr: number): void {
16236 if(!isWasmInitialized) {
16237 throw new Error("initializeWasm() must be awaited first!");
16239 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
16240 // debug statements here
16242 // void EventHandler_free(struct LDKEventHandler this_ptr);
16244 export function EventHandler_free(this_ptr: number): void {
16245 if(!isWasmInitialized) {
16246 throw new Error("initializeWasm() must be awaited first!");
16248 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
16249 // debug statements here
16251 // void APIError_free(struct LDKAPIError this_ptr);
16253 export function APIError_free(this_ptr: number): void {
16254 if(!isWasmInitialized) {
16255 throw new Error("initializeWasm() must be awaited first!");
16257 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
16258 // debug statements here
16260 // uintptr_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
16262 export function APIError_clone_ptr(arg: number): number {
16263 if(!isWasmInitialized) {
16264 throw new Error("initializeWasm() must be awaited first!");
16266 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
16267 return nativeResponseValue;
16269 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
16271 export function APIError_clone(orig: number): number {
16272 if(!isWasmInitialized) {
16273 throw new Error("initializeWasm() must be awaited first!");
16275 const nativeResponseValue = wasm.TS_APIError_clone(orig);
16276 return nativeResponseValue;
16278 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
16280 export function APIError_apimisuse_error(err: number): number {
16281 if(!isWasmInitialized) {
16282 throw new Error("initializeWasm() must be awaited first!");
16284 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
16285 return nativeResponseValue;
16287 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
16289 export function APIError_fee_rate_too_high(err: number, feerate: number): number {
16290 if(!isWasmInitialized) {
16291 throw new Error("initializeWasm() must be awaited first!");
16293 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
16294 return nativeResponseValue;
16296 // struct LDKAPIError APIError_route_error(struct LDKStr err);
16298 export function APIError_route_error(err: number): number {
16299 if(!isWasmInitialized) {
16300 throw new Error("initializeWasm() must be awaited first!");
16302 const nativeResponseValue = wasm.TS_APIError_route_error(err);
16303 return nativeResponseValue;
16305 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
16307 export function APIError_channel_unavailable(err: number): number {
16308 if(!isWasmInitialized) {
16309 throw new Error("initializeWasm() must be awaited first!");
16311 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
16312 return nativeResponseValue;
16314 // struct LDKAPIError APIError_monitor_update_failed(void);
16316 export function APIError_monitor_update_failed(): number {
16317 if(!isWasmInitialized) {
16318 throw new Error("initializeWasm() must be awaited first!");
16320 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
16321 return nativeResponseValue;
16323 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
16325 export function APIError_incompatible_shutdown_script(script: number): number {
16326 if(!isWasmInitialized) {
16327 throw new Error("initializeWasm() must be awaited first!");
16329 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
16330 return nativeResponseValue;
16332 // void BigSize_free(struct LDKBigSize this_obj);
16334 export function BigSize_free(this_obj: number): void {
16335 if(!isWasmInitialized) {
16336 throw new Error("initializeWasm() must be awaited first!");
16338 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
16339 // debug statements here
16341 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
16343 export function BigSize_get_a(this_ptr: number): bigint {
16344 if(!isWasmInitialized) {
16345 throw new Error("initializeWasm() must be awaited first!");
16347 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
16348 return nativeResponseValue;
16350 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
16352 export function BigSize_set_a(this_ptr: number, val: bigint): void {
16353 if(!isWasmInitialized) {
16354 throw new Error("initializeWasm() must be awaited first!");
16356 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
16357 // debug statements here
16359 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
16361 export function BigSize_new(a_arg: bigint): number {
16362 if(!isWasmInitialized) {
16363 throw new Error("initializeWasm() must be awaited first!");
16365 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
16366 return nativeResponseValue;
16368 // void Hostname_free(struct LDKHostname this_obj);
16370 export function Hostname_free(this_obj: number): void {
16371 if(!isWasmInitialized) {
16372 throw new Error("initializeWasm() must be awaited first!");
16374 const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
16375 // debug statements here
16377 // uintptr_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
16379 export function Hostname_clone_ptr(arg: number): number {
16380 if(!isWasmInitialized) {
16381 throw new Error("initializeWasm() must be awaited first!");
16383 const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
16384 return nativeResponseValue;
16386 // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
16388 export function Hostname_clone(orig: number): number {
16389 if(!isWasmInitialized) {
16390 throw new Error("initializeWasm() must be awaited first!");
16392 const nativeResponseValue = wasm.TS_Hostname_clone(orig);
16393 return nativeResponseValue;
16395 // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
16397 export function Hostname_len(this_arg: number): number {
16398 if(!isWasmInitialized) {
16399 throw new Error("initializeWasm() must be awaited first!");
16401 const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
16402 return nativeResponseValue;
16404 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
16406 export function sign(msg: number, sk: number): number {
16407 if(!isWasmInitialized) {
16408 throw new Error("initializeWasm() must be awaited first!");
16410 const nativeResponseValue = wasm.TS_sign(msg, sk);
16411 return nativeResponseValue;
16413 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
16415 export function recover_pk(msg: number, sig: number): number {
16416 if(!isWasmInitialized) {
16417 throw new Error("initializeWasm() must be awaited first!");
16419 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
16420 return nativeResponseValue;
16422 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
16424 export function verify(msg: number, sig: number, pk: number): boolean {
16425 if(!isWasmInitialized) {
16426 throw new Error("initializeWasm() must be awaited first!");
16428 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
16429 return nativeResponseValue;
16431 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z data_without_signature);
16433 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
16434 if(!isWasmInitialized) {
16435 throw new Error("initializeWasm() must be awaited first!");
16437 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
16438 return nativeResponseValue;
16440 // void Persister_free(struct LDKPersister this_ptr);
16442 export function Persister_free(this_ptr: number): void {
16443 if(!isWasmInitialized) {
16444 throw new Error("initializeWasm() must be awaited first!");
16446 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
16447 // debug statements here
16449 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
16451 export function Level_clone(orig: number): Level {
16452 if(!isWasmInitialized) {
16453 throw new Error("initializeWasm() must be awaited first!");
16455 const nativeResponseValue = wasm.TS_Level_clone(orig);
16456 return nativeResponseValue;
16458 // enum LDKLevel Level_gossip(void);
16460 export function Level_gossip(): Level {
16461 if(!isWasmInitialized) {
16462 throw new Error("initializeWasm() must be awaited first!");
16464 const nativeResponseValue = wasm.TS_Level_gossip();
16465 return nativeResponseValue;
16467 // enum LDKLevel Level_trace(void);
16469 export function Level_trace(): Level {
16470 if(!isWasmInitialized) {
16471 throw new Error("initializeWasm() must be awaited first!");
16473 const nativeResponseValue = wasm.TS_Level_trace();
16474 return nativeResponseValue;
16476 // enum LDKLevel Level_debug(void);
16478 export function Level_debug(): Level {
16479 if(!isWasmInitialized) {
16480 throw new Error("initializeWasm() must be awaited first!");
16482 const nativeResponseValue = wasm.TS_Level_debug();
16483 return nativeResponseValue;
16485 // enum LDKLevel Level_info(void);
16487 export function Level_info(): Level {
16488 if(!isWasmInitialized) {
16489 throw new Error("initializeWasm() must be awaited first!");
16491 const nativeResponseValue = wasm.TS_Level_info();
16492 return nativeResponseValue;
16494 // enum LDKLevel Level_warn(void);
16496 export function Level_warn(): Level {
16497 if(!isWasmInitialized) {
16498 throw new Error("initializeWasm() must be awaited first!");
16500 const nativeResponseValue = wasm.TS_Level_warn();
16501 return nativeResponseValue;
16503 // enum LDKLevel Level_error(void);
16505 export function Level_error(): Level {
16506 if(!isWasmInitialized) {
16507 throw new Error("initializeWasm() must be awaited first!");
16509 const nativeResponseValue = wasm.TS_Level_error();
16510 return nativeResponseValue;
16512 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
16514 export function Level_eq(a: number, b: number): boolean {
16515 if(!isWasmInitialized) {
16516 throw new Error("initializeWasm() must be awaited first!");
16518 const nativeResponseValue = wasm.TS_Level_eq(a, b);
16519 return nativeResponseValue;
16521 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
16523 export function Level_hash(o: number): bigint {
16524 if(!isWasmInitialized) {
16525 throw new Error("initializeWasm() must be awaited first!");
16527 const nativeResponseValue = wasm.TS_Level_hash(o);
16528 return nativeResponseValue;
16530 // MUST_USE_RES enum LDKLevel Level_max(void);
16532 export function Level_max(): Level {
16533 if(!isWasmInitialized) {
16534 throw new Error("initializeWasm() must be awaited first!");
16536 const nativeResponseValue = wasm.TS_Level_max();
16537 return nativeResponseValue;
16539 // void Record_free(struct LDKRecord this_obj);
16541 export function Record_free(this_obj: number): void {
16542 if(!isWasmInitialized) {
16543 throw new Error("initializeWasm() must be awaited first!");
16545 const nativeResponseValue = wasm.TS_Record_free(this_obj);
16546 // debug statements here
16548 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
16550 export function Record_get_level(this_ptr: number): Level {
16551 if(!isWasmInitialized) {
16552 throw new Error("initializeWasm() must be awaited first!");
16554 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
16555 return nativeResponseValue;
16557 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
16559 export function Record_set_level(this_ptr: number, val: Level): void {
16560 if(!isWasmInitialized) {
16561 throw new Error("initializeWasm() must be awaited first!");
16563 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
16564 // debug statements here
16566 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
16568 export function Record_get_args(this_ptr: number): number {
16569 if(!isWasmInitialized) {
16570 throw new Error("initializeWasm() must be awaited first!");
16572 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
16573 return nativeResponseValue;
16575 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16577 export function Record_set_args(this_ptr: number, val: number): void {
16578 if(!isWasmInitialized) {
16579 throw new Error("initializeWasm() must be awaited first!");
16581 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
16582 // debug statements here
16584 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
16586 export function Record_get_module_path(this_ptr: number): number {
16587 if(!isWasmInitialized) {
16588 throw new Error("initializeWasm() must be awaited first!");
16590 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
16591 return nativeResponseValue;
16593 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16595 export function Record_set_module_path(this_ptr: number, val: number): void {
16596 if(!isWasmInitialized) {
16597 throw new Error("initializeWasm() must be awaited first!");
16599 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
16600 // debug statements here
16602 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
16604 export function Record_get_file(this_ptr: number): number {
16605 if(!isWasmInitialized) {
16606 throw new Error("initializeWasm() must be awaited first!");
16608 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
16609 return nativeResponseValue;
16611 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16613 export function Record_set_file(this_ptr: number, val: number): void {
16614 if(!isWasmInitialized) {
16615 throw new Error("initializeWasm() must be awaited first!");
16617 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
16618 // debug statements here
16620 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
16622 export function Record_get_line(this_ptr: number): number {
16623 if(!isWasmInitialized) {
16624 throw new Error("initializeWasm() must be awaited first!");
16626 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
16627 return nativeResponseValue;
16629 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
16631 export function Record_set_line(this_ptr: number, val: number): void {
16632 if(!isWasmInitialized) {
16633 throw new Error("initializeWasm() must be awaited first!");
16635 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
16636 // debug statements here
16638 // uintptr_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
16640 export function Record_clone_ptr(arg: number): number {
16641 if(!isWasmInitialized) {
16642 throw new Error("initializeWasm() must be awaited first!");
16644 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
16645 return nativeResponseValue;
16647 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
16649 export function Record_clone(orig: number): number {
16650 if(!isWasmInitialized) {
16651 throw new Error("initializeWasm() must be awaited first!");
16653 const nativeResponseValue = wasm.TS_Record_clone(orig);
16654 return nativeResponseValue;
16656 // void Logger_free(struct LDKLogger this_ptr);
16658 export function Logger_free(this_ptr: number): void {
16659 if(!isWasmInitialized) {
16660 throw new Error("initializeWasm() must be awaited first!");
16662 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
16663 // debug statements here
16665 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
16667 export function ChannelHandshakeConfig_free(this_obj: number): void {
16668 if(!isWasmInitialized) {
16669 throw new Error("initializeWasm() must be awaited first!");
16671 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
16672 // debug statements here
16674 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16676 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
16677 if(!isWasmInitialized) {
16678 throw new Error("initializeWasm() must be awaited first!");
16680 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
16681 return nativeResponseValue;
16683 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
16685 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
16686 if(!isWasmInitialized) {
16687 throw new Error("initializeWasm() must be awaited first!");
16689 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
16690 // debug statements here
16692 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16694 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
16695 if(!isWasmInitialized) {
16696 throw new Error("initializeWasm() must be awaited first!");
16698 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
16699 return nativeResponseValue;
16701 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
16703 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: number, val: number): void {
16704 if(!isWasmInitialized) {
16705 throw new Error("initializeWasm() must be awaited first!");
16707 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
16708 // debug statements here
16710 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16712 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): bigint {
16713 if(!isWasmInitialized) {
16714 throw new Error("initializeWasm() must be awaited first!");
16716 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
16717 return nativeResponseValue;
16719 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
16721 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16722 if(!isWasmInitialized) {
16723 throw new Error("initializeWasm() must be awaited first!");
16725 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
16726 // debug statements here
16728 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16730 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: number): number {
16731 if(!isWasmInitialized) {
16732 throw new Error("initializeWasm() must be awaited first!");
16734 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
16735 return nativeResponseValue;
16737 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
16739 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: number, val: number): void {
16740 if(!isWasmInitialized) {
16741 throw new Error("initializeWasm() must be awaited first!");
16743 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
16744 // debug statements here
16746 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16748 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: number): boolean {
16749 if(!isWasmInitialized) {
16750 throw new Error("initializeWasm() must be awaited first!");
16752 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
16753 return nativeResponseValue;
16755 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16757 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: number, val: boolean): void {
16758 if(!isWasmInitialized) {
16759 throw new Error("initializeWasm() must be awaited first!");
16761 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
16762 // debug statements here
16764 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16766 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: number): boolean {
16767 if(!isWasmInitialized) {
16768 throw new Error("initializeWasm() must be awaited first!");
16770 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
16771 return nativeResponseValue;
16773 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16775 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: number, val: boolean): void {
16776 if(!isWasmInitialized) {
16777 throw new Error("initializeWasm() must be awaited first!");
16779 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
16780 // debug statements here
16782 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16784 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: number): boolean {
16785 if(!isWasmInitialized) {
16786 throw new Error("initializeWasm() must be awaited first!");
16788 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
16789 return nativeResponseValue;
16791 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16793 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: number, val: boolean): void {
16794 if(!isWasmInitialized) {
16795 throw new Error("initializeWasm() must be awaited first!");
16797 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
16798 // debug statements here
16800 // 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);
16802 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 {
16803 if(!isWasmInitialized) {
16804 throw new Error("initializeWasm() must be awaited first!");
16806 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);
16807 return nativeResponseValue;
16809 // uintptr_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
16811 export function ChannelHandshakeConfig_clone_ptr(arg: number): number {
16812 if(!isWasmInitialized) {
16813 throw new Error("initializeWasm() must be awaited first!");
16815 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
16816 return nativeResponseValue;
16818 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
16820 export function ChannelHandshakeConfig_clone(orig: number): number {
16821 if(!isWasmInitialized) {
16822 throw new Error("initializeWasm() must be awaited first!");
16824 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
16825 return nativeResponseValue;
16827 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
16829 export function ChannelHandshakeConfig_default(): number {
16830 if(!isWasmInitialized) {
16831 throw new Error("initializeWasm() must be awaited first!");
16833 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
16834 return nativeResponseValue;
16836 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
16838 export function ChannelHandshakeLimits_free(this_obj: number): void {
16839 if(!isWasmInitialized) {
16840 throw new Error("initializeWasm() must be awaited first!");
16842 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
16843 // debug statements here
16845 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16847 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): bigint {
16848 if(!isWasmInitialized) {
16849 throw new Error("initializeWasm() must be awaited first!");
16851 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
16852 return nativeResponseValue;
16854 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16856 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: bigint): void {
16857 if(!isWasmInitialized) {
16858 throw new Error("initializeWasm() must be awaited first!");
16860 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
16861 // debug statements here
16863 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16865 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: number): bigint {
16866 if(!isWasmInitialized) {
16867 throw new Error("initializeWasm() must be awaited first!");
16869 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
16870 return nativeResponseValue;
16872 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16874 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: number, val: bigint): void {
16875 if(!isWasmInitialized) {
16876 throw new Error("initializeWasm() must be awaited first!");
16878 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
16879 // debug statements here
16881 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16883 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): bigint {
16884 if(!isWasmInitialized) {
16885 throw new Error("initializeWasm() must be awaited first!");
16887 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
16888 return nativeResponseValue;
16890 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16892 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16893 if(!isWasmInitialized) {
16894 throw new Error("initializeWasm() must be awaited first!");
16896 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
16897 // debug statements here
16899 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16901 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
16902 if(!isWasmInitialized) {
16903 throw new Error("initializeWasm() must be awaited first!");
16905 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
16906 return nativeResponseValue;
16908 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16910 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
16911 if(!isWasmInitialized) {
16912 throw new Error("initializeWasm() must be awaited first!");
16914 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
16915 // debug statements here
16917 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16919 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): bigint {
16920 if(!isWasmInitialized) {
16921 throw new Error("initializeWasm() must be awaited first!");
16923 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
16924 return nativeResponseValue;
16926 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16928 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
16929 if(!isWasmInitialized) {
16930 throw new Error("initializeWasm() must be awaited first!");
16932 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
16933 // debug statements here
16935 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16937 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
16938 if(!isWasmInitialized) {
16939 throw new Error("initializeWasm() must be awaited first!");
16941 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
16942 return nativeResponseValue;
16944 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
16946 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
16947 if(!isWasmInitialized) {
16948 throw new Error("initializeWasm() must be awaited first!");
16950 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
16951 // debug statements here
16953 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16955 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
16956 if(!isWasmInitialized) {
16957 throw new Error("initializeWasm() must be awaited first!");
16959 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
16960 return nativeResponseValue;
16962 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
16964 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: number, val: number): void {
16965 if(!isWasmInitialized) {
16966 throw new Error("initializeWasm() must be awaited first!");
16968 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
16969 // debug statements here
16971 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16973 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: number): boolean {
16974 if(!isWasmInitialized) {
16975 throw new Error("initializeWasm() must be awaited first!");
16977 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
16978 return nativeResponseValue;
16980 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
16982 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: number, val: boolean): void {
16983 if(!isWasmInitialized) {
16984 throw new Error("initializeWasm() must be awaited first!");
16986 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
16987 // debug statements here
16989 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16991 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
16992 if(!isWasmInitialized) {
16993 throw new Error("initializeWasm() must be awaited first!");
16995 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
16996 return nativeResponseValue;
16998 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
17000 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
17001 if(!isWasmInitialized) {
17002 throw new Error("initializeWasm() must be awaited first!");
17004 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
17005 // debug statements here
17007 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
17009 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
17010 if(!isWasmInitialized) {
17011 throw new Error("initializeWasm() must be awaited first!");
17013 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
17014 return nativeResponseValue;
17016 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
17018 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
17019 if(!isWasmInitialized) {
17020 throw new Error("initializeWasm() must be awaited first!");
17022 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
17023 // debug statements here
17025 // 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);
17027 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 {
17028 if(!isWasmInitialized) {
17029 throw new Error("initializeWasm() must be awaited first!");
17031 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);
17032 return nativeResponseValue;
17034 // uintptr_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
17036 export function ChannelHandshakeLimits_clone_ptr(arg: number): number {
17037 if(!isWasmInitialized) {
17038 throw new Error("initializeWasm() must be awaited first!");
17040 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
17041 return nativeResponseValue;
17043 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
17045 export function ChannelHandshakeLimits_clone(orig: number): number {
17046 if(!isWasmInitialized) {
17047 throw new Error("initializeWasm() must be awaited first!");
17049 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
17050 return nativeResponseValue;
17052 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
17054 export function ChannelHandshakeLimits_default(): number {
17055 if(!isWasmInitialized) {
17056 throw new Error("initializeWasm() must be awaited first!");
17058 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
17059 return nativeResponseValue;
17061 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
17063 export function ChannelConfig_free(this_obj: number): void {
17064 if(!isWasmInitialized) {
17065 throw new Error("initializeWasm() must be awaited first!");
17067 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
17068 // debug statements here
17070 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17072 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: number): number {
17073 if(!isWasmInitialized) {
17074 throw new Error("initializeWasm() must be awaited first!");
17076 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
17077 return nativeResponseValue;
17079 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
17081 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: number, val: number): void {
17082 if(!isWasmInitialized) {
17083 throw new Error("initializeWasm() must be awaited first!");
17085 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
17086 // debug statements here
17088 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17090 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: number): number {
17091 if(!isWasmInitialized) {
17092 throw new Error("initializeWasm() must be awaited first!");
17094 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
17095 return nativeResponseValue;
17097 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
17099 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: number, val: number): void {
17100 if(!isWasmInitialized) {
17101 throw new Error("initializeWasm() must be awaited first!");
17103 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
17104 // debug statements here
17106 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17108 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
17109 if(!isWasmInitialized) {
17110 throw new Error("initializeWasm() must be awaited first!");
17112 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
17113 return nativeResponseValue;
17115 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
17117 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
17118 if(!isWasmInitialized) {
17119 throw new Error("initializeWasm() must be awaited first!");
17121 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
17122 // debug statements here
17124 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17126 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: number): bigint {
17127 if(!isWasmInitialized) {
17128 throw new Error("initializeWasm() must be awaited first!");
17130 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
17131 return nativeResponseValue;
17133 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
17135 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: number, val: bigint): void {
17136 if(!isWasmInitialized) {
17137 throw new Error("initializeWasm() must be awaited first!");
17139 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
17140 // debug statements here
17142 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
17144 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: number): bigint {
17145 if(!isWasmInitialized) {
17146 throw new Error("initializeWasm() must be awaited first!");
17148 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
17149 return nativeResponseValue;
17151 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
17153 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: number, val: bigint): void {
17154 if(!isWasmInitialized) {
17155 throw new Error("initializeWasm() must be awaited first!");
17157 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
17158 // debug statements here
17160 // 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);
17162 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 {
17163 if(!isWasmInitialized) {
17164 throw new Error("initializeWasm() must be awaited first!");
17166 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);
17167 return nativeResponseValue;
17169 // uintptr_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
17171 export function ChannelConfig_clone_ptr(arg: number): number {
17172 if(!isWasmInitialized) {
17173 throw new Error("initializeWasm() must be awaited first!");
17175 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
17176 return nativeResponseValue;
17178 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
17180 export function ChannelConfig_clone(orig: number): number {
17181 if(!isWasmInitialized) {
17182 throw new Error("initializeWasm() must be awaited first!");
17184 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
17185 return nativeResponseValue;
17187 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
17189 export function ChannelConfig_default(): number {
17190 if(!isWasmInitialized) {
17191 throw new Error("initializeWasm() must be awaited first!");
17193 const nativeResponseValue = wasm.TS_ChannelConfig_default();
17194 return nativeResponseValue;
17196 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
17198 export function ChannelConfig_write(obj: number): number {
17199 if(!isWasmInitialized) {
17200 throw new Error("initializeWasm() must be awaited first!");
17202 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
17203 return nativeResponseValue;
17205 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
17207 export function ChannelConfig_read(ser: number): number {
17208 if(!isWasmInitialized) {
17209 throw new Error("initializeWasm() must be awaited first!");
17211 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
17212 return nativeResponseValue;
17214 // void UserConfig_free(struct LDKUserConfig this_obj);
17216 export function UserConfig_free(this_obj: number): void {
17217 if(!isWasmInitialized) {
17218 throw new Error("initializeWasm() must be awaited first!");
17220 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
17221 // debug statements here
17223 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17225 export function UserConfig_get_channel_handshake_config(this_ptr: number): number {
17226 if(!isWasmInitialized) {
17227 throw new Error("initializeWasm() must be awaited first!");
17229 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
17230 return nativeResponseValue;
17232 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
17234 export function UserConfig_set_channel_handshake_config(this_ptr: number, val: number): void {
17235 if(!isWasmInitialized) {
17236 throw new Error("initializeWasm() must be awaited first!");
17238 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
17239 // debug statements here
17241 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17243 export function UserConfig_get_channel_handshake_limits(this_ptr: number): number {
17244 if(!isWasmInitialized) {
17245 throw new Error("initializeWasm() must be awaited first!");
17247 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
17248 return nativeResponseValue;
17250 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
17252 export function UserConfig_set_channel_handshake_limits(this_ptr: number, val: number): void {
17253 if(!isWasmInitialized) {
17254 throw new Error("initializeWasm() must be awaited first!");
17256 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
17257 // debug statements here
17259 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17261 export function UserConfig_get_channel_config(this_ptr: number): number {
17262 if(!isWasmInitialized) {
17263 throw new Error("initializeWasm() must be awaited first!");
17265 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
17266 return nativeResponseValue;
17268 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
17270 export function UserConfig_set_channel_config(this_ptr: number, val: number): void {
17271 if(!isWasmInitialized) {
17272 throw new Error("initializeWasm() must be awaited first!");
17274 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
17275 // debug statements here
17277 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17279 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: number): boolean {
17280 if(!isWasmInitialized) {
17281 throw new Error("initializeWasm() must be awaited first!");
17283 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
17284 return nativeResponseValue;
17286 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
17288 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: number, val: boolean): void {
17289 if(!isWasmInitialized) {
17290 throw new Error("initializeWasm() must be awaited first!");
17292 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
17293 // debug statements here
17295 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17297 export function UserConfig_get_accept_inbound_channels(this_ptr: number): boolean {
17298 if(!isWasmInitialized) {
17299 throw new Error("initializeWasm() must be awaited first!");
17301 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
17302 return nativeResponseValue;
17304 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
17306 export function UserConfig_set_accept_inbound_channels(this_ptr: number, val: boolean): void {
17307 if(!isWasmInitialized) {
17308 throw new Error("initializeWasm() must be awaited first!");
17310 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
17311 // debug statements here
17313 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
17315 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: number): boolean {
17316 if(!isWasmInitialized) {
17317 throw new Error("initializeWasm() must be awaited first!");
17319 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
17320 return nativeResponseValue;
17322 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
17324 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: number, val: boolean): void {
17325 if(!isWasmInitialized) {
17326 throw new Error("initializeWasm() must be awaited first!");
17328 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
17329 // debug statements here
17331 // 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);
17333 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 {
17334 if(!isWasmInitialized) {
17335 throw new Error("initializeWasm() must be awaited first!");
17337 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);
17338 return nativeResponseValue;
17340 // uintptr_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
17342 export function UserConfig_clone_ptr(arg: number): number {
17343 if(!isWasmInitialized) {
17344 throw new Error("initializeWasm() must be awaited first!");
17346 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
17347 return nativeResponseValue;
17349 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
17351 export function UserConfig_clone(orig: number): number {
17352 if(!isWasmInitialized) {
17353 throw new Error("initializeWasm() must be awaited first!");
17355 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
17356 return nativeResponseValue;
17358 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
17360 export function UserConfig_default(): number {
17361 if(!isWasmInitialized) {
17362 throw new Error("initializeWasm() must be awaited first!");
17364 const nativeResponseValue = wasm.TS_UserConfig_default();
17365 return nativeResponseValue;
17367 // void BestBlock_free(struct LDKBestBlock this_obj);
17369 export function BestBlock_free(this_obj: number): void {
17370 if(!isWasmInitialized) {
17371 throw new Error("initializeWasm() must be awaited first!");
17373 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
17374 // debug statements here
17376 // uintptr_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
17378 export function BestBlock_clone_ptr(arg: number): number {
17379 if(!isWasmInitialized) {
17380 throw new Error("initializeWasm() must be awaited first!");
17382 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
17383 return nativeResponseValue;
17385 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
17387 export function BestBlock_clone(orig: number): number {
17388 if(!isWasmInitialized) {
17389 throw new Error("initializeWasm() must be awaited first!");
17391 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
17392 return nativeResponseValue;
17394 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
17396 export function BestBlock_from_genesis(network: Network): number {
17397 if(!isWasmInitialized) {
17398 throw new Error("initializeWasm() must be awaited first!");
17400 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
17401 return nativeResponseValue;
17403 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
17405 export function BestBlock_new(block_hash: number, height: number): number {
17406 if(!isWasmInitialized) {
17407 throw new Error("initializeWasm() must be awaited first!");
17409 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
17410 return nativeResponseValue;
17412 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
17414 export function BestBlock_block_hash(this_arg: number): number {
17415 if(!isWasmInitialized) {
17416 throw new Error("initializeWasm() must be awaited first!");
17418 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
17419 return nativeResponseValue;
17421 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
17423 export function BestBlock_height(this_arg: number): number {
17424 if(!isWasmInitialized) {
17425 throw new Error("initializeWasm() must be awaited first!");
17427 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
17428 return nativeResponseValue;
17430 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
17432 export function AccessError_clone(orig: number): AccessError {
17433 if(!isWasmInitialized) {
17434 throw new Error("initializeWasm() must be awaited first!");
17436 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
17437 return nativeResponseValue;
17439 // enum LDKAccessError AccessError_unknown_chain(void);
17441 export function AccessError_unknown_chain(): AccessError {
17442 if(!isWasmInitialized) {
17443 throw new Error("initializeWasm() must be awaited first!");
17445 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
17446 return nativeResponseValue;
17448 // enum LDKAccessError AccessError_unknown_tx(void);
17450 export function AccessError_unknown_tx(): AccessError {
17451 if(!isWasmInitialized) {
17452 throw new Error("initializeWasm() must be awaited first!");
17454 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
17455 return nativeResponseValue;
17457 // void Access_free(struct LDKAccess this_ptr);
17459 export function Access_free(this_ptr: number): void {
17460 if(!isWasmInitialized) {
17461 throw new Error("initializeWasm() must be awaited first!");
17463 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
17464 // debug statements here
17466 // void Listen_free(struct LDKListen this_ptr);
17468 export function Listen_free(this_ptr: number): void {
17469 if(!isWasmInitialized) {
17470 throw new Error("initializeWasm() must be awaited first!");
17472 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
17473 // debug statements here
17475 // void Confirm_free(struct LDKConfirm this_ptr);
17477 export function Confirm_free(this_ptr: number): void {
17478 if(!isWasmInitialized) {
17479 throw new Error("initializeWasm() must be awaited first!");
17481 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
17482 // debug statements here
17484 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
17486 export function ChannelMonitorUpdateErr_clone(orig: number): ChannelMonitorUpdateErr {
17487 if(!isWasmInitialized) {
17488 throw new Error("initializeWasm() must be awaited first!");
17490 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
17491 return nativeResponseValue;
17493 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
17495 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
17496 if(!isWasmInitialized) {
17497 throw new Error("initializeWasm() must be awaited first!");
17499 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
17500 return nativeResponseValue;
17502 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
17504 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
17505 if(!isWasmInitialized) {
17506 throw new Error("initializeWasm() must be awaited first!");
17508 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
17509 return nativeResponseValue;
17511 // void Watch_free(struct LDKWatch this_ptr);
17513 export function Watch_free(this_ptr: number): void {
17514 if(!isWasmInitialized) {
17515 throw new Error("initializeWasm() must be awaited first!");
17517 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
17518 // debug statements here
17520 // void Filter_free(struct LDKFilter this_ptr);
17522 export function Filter_free(this_ptr: number): void {
17523 if(!isWasmInitialized) {
17524 throw new Error("initializeWasm() must be awaited first!");
17526 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
17527 // debug statements here
17529 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
17531 export function WatchedOutput_free(this_obj: number): void {
17532 if(!isWasmInitialized) {
17533 throw new Error("initializeWasm() must be awaited first!");
17535 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
17536 // debug statements here
17538 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17540 export function WatchedOutput_get_block_hash(this_ptr: number): number {
17541 if(!isWasmInitialized) {
17542 throw new Error("initializeWasm() must be awaited first!");
17544 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
17545 return nativeResponseValue;
17547 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17549 export function WatchedOutput_set_block_hash(this_ptr: number, val: number): void {
17550 if(!isWasmInitialized) {
17551 throw new Error("initializeWasm() must be awaited first!");
17553 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
17554 // debug statements here
17556 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17558 export function WatchedOutput_get_outpoint(this_ptr: number): number {
17559 if(!isWasmInitialized) {
17560 throw new Error("initializeWasm() must be awaited first!");
17562 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
17563 return nativeResponseValue;
17565 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17567 export function WatchedOutput_set_outpoint(this_ptr: number, val: number): void {
17568 if(!isWasmInitialized) {
17569 throw new Error("initializeWasm() must be awaited first!");
17571 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
17572 // debug statements here
17574 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17576 export function WatchedOutput_get_script_pubkey(this_ptr: number): number {
17577 if(!isWasmInitialized) {
17578 throw new Error("initializeWasm() must be awaited first!");
17580 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
17581 return nativeResponseValue;
17583 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
17585 export function WatchedOutput_set_script_pubkey(this_ptr: number, val: number): void {
17586 if(!isWasmInitialized) {
17587 throw new Error("initializeWasm() must be awaited first!");
17589 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
17590 // debug statements here
17592 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
17594 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: number, script_pubkey_arg: number): number {
17595 if(!isWasmInitialized) {
17596 throw new Error("initializeWasm() must be awaited first!");
17598 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
17599 return nativeResponseValue;
17601 // uintptr_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
17603 export function WatchedOutput_clone_ptr(arg: number): number {
17604 if(!isWasmInitialized) {
17605 throw new Error("initializeWasm() must be awaited first!");
17607 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
17608 return nativeResponseValue;
17610 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
17612 export function WatchedOutput_clone(orig: number): number {
17613 if(!isWasmInitialized) {
17614 throw new Error("initializeWasm() must be awaited first!");
17616 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
17617 return nativeResponseValue;
17619 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
17621 export function WatchedOutput_hash(o: number): bigint {
17622 if(!isWasmInitialized) {
17623 throw new Error("initializeWasm() must be awaited first!");
17625 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
17626 return nativeResponseValue;
17628 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
17630 export function BroadcasterInterface_free(this_ptr: number): void {
17631 if(!isWasmInitialized) {
17632 throw new Error("initializeWasm() must be awaited first!");
17634 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
17635 // debug statements here
17637 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
17639 export function ConfirmationTarget_clone(orig: number): ConfirmationTarget {
17640 if(!isWasmInitialized) {
17641 throw new Error("initializeWasm() must be awaited first!");
17643 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
17644 return nativeResponseValue;
17646 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
17648 export function ConfirmationTarget_background(): ConfirmationTarget {
17649 if(!isWasmInitialized) {
17650 throw new Error("initializeWasm() must be awaited first!");
17652 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
17653 return nativeResponseValue;
17655 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
17657 export function ConfirmationTarget_normal(): ConfirmationTarget {
17658 if(!isWasmInitialized) {
17659 throw new Error("initializeWasm() must be awaited first!");
17661 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
17662 return nativeResponseValue;
17664 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
17666 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
17667 if(!isWasmInitialized) {
17668 throw new Error("initializeWasm() must be awaited first!");
17670 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
17671 return nativeResponseValue;
17673 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
17675 export function ConfirmationTarget_eq(a: number, b: number): boolean {
17676 if(!isWasmInitialized) {
17677 throw new Error("initializeWasm() must be awaited first!");
17679 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
17680 return nativeResponseValue;
17682 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
17684 export function FeeEstimator_free(this_ptr: number): void {
17685 if(!isWasmInitialized) {
17686 throw new Error("initializeWasm() must be awaited first!");
17688 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
17689 // debug statements here
17691 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
17693 export function MonitorUpdateId_free(this_obj: number): void {
17694 if(!isWasmInitialized) {
17695 throw new Error("initializeWasm() must be awaited first!");
17697 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
17698 // debug statements here
17700 // uintptr_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
17702 export function MonitorUpdateId_clone_ptr(arg: number): number {
17703 if(!isWasmInitialized) {
17704 throw new Error("initializeWasm() must be awaited first!");
17706 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
17707 return nativeResponseValue;
17709 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
17711 export function MonitorUpdateId_clone(orig: number): number {
17712 if(!isWasmInitialized) {
17713 throw new Error("initializeWasm() must be awaited first!");
17715 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
17716 return nativeResponseValue;
17718 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
17720 export function MonitorUpdateId_hash(o: number): bigint {
17721 if(!isWasmInitialized) {
17722 throw new Error("initializeWasm() must be awaited first!");
17724 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
17725 return nativeResponseValue;
17727 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
17729 export function MonitorUpdateId_eq(a: number, b: number): boolean {
17730 if(!isWasmInitialized) {
17731 throw new Error("initializeWasm() must be awaited first!");
17733 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
17734 return nativeResponseValue;
17736 // void Persist_free(struct LDKPersist this_ptr);
17738 export function Persist_free(this_ptr: number): void {
17739 if(!isWasmInitialized) {
17740 throw new Error("initializeWasm() must be awaited first!");
17742 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
17743 // debug statements here
17745 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
17747 export function LockedChannelMonitor_free(this_obj: number): void {
17748 if(!isWasmInitialized) {
17749 throw new Error("initializeWasm() must be awaited first!");
17751 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
17752 // debug statements here
17754 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
17756 export function ChainMonitor_free(this_obj: number): void {
17757 if(!isWasmInitialized) {
17758 throw new Error("initializeWasm() must be awaited first!");
17760 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
17761 // debug statements here
17763 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
17765 export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
17766 if(!isWasmInitialized) {
17767 throw new Error("initializeWasm() must be awaited first!");
17769 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
17770 return nativeResponseValue;
17772 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
17774 export function ChainMonitor_get_claimable_balances(this_arg: number, ignored_channels: number): number {
17775 if(!isWasmInitialized) {
17776 throw new Error("initializeWasm() must be awaited first!");
17778 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
17779 return nativeResponseValue;
17781 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
17783 export function ChainMonitor_get_monitor(this_arg: number, funding_txo: number): number {
17784 if(!isWasmInitialized) {
17785 throw new Error("initializeWasm() must be awaited first!");
17787 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
17788 return nativeResponseValue;
17790 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17792 export function ChainMonitor_list_monitors(this_arg: number): number {
17793 if(!isWasmInitialized) {
17794 throw new Error("initializeWasm() must be awaited first!");
17796 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
17797 return nativeResponseValue;
17799 // 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);
17801 export function ChainMonitor_channel_monitor_updated(this_arg: number, funding_txo: number, completed_update_id: number): number {
17802 if(!isWasmInitialized) {
17803 throw new Error("initializeWasm() must be awaited first!");
17805 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
17806 return nativeResponseValue;
17808 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17810 export function ChainMonitor_as_Listen(this_arg: number): number {
17811 if(!isWasmInitialized) {
17812 throw new Error("initializeWasm() must be awaited first!");
17814 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
17815 return nativeResponseValue;
17817 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17819 export function ChainMonitor_as_Confirm(this_arg: number): number {
17820 if(!isWasmInitialized) {
17821 throw new Error("initializeWasm() must be awaited first!");
17823 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
17824 return nativeResponseValue;
17826 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17828 export function ChainMonitor_as_Watch(this_arg: number): number {
17829 if(!isWasmInitialized) {
17830 throw new Error("initializeWasm() must be awaited first!");
17832 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
17833 return nativeResponseValue;
17835 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17837 export function ChainMonitor_as_EventsProvider(this_arg: number): number {
17838 if(!isWasmInitialized) {
17839 throw new Error("initializeWasm() must be awaited first!");
17841 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
17842 return nativeResponseValue;
17844 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
17846 export function ChannelMonitorUpdate_free(this_obj: number): void {
17847 if(!isWasmInitialized) {
17848 throw new Error("initializeWasm() must be awaited first!");
17850 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
17851 // debug statements here
17853 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
17855 export function ChannelMonitorUpdate_get_update_id(this_ptr: number): bigint {
17856 if(!isWasmInitialized) {
17857 throw new Error("initializeWasm() must be awaited first!");
17859 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
17860 return nativeResponseValue;
17862 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
17864 export function ChannelMonitorUpdate_set_update_id(this_ptr: number, val: bigint): void {
17865 if(!isWasmInitialized) {
17866 throw new Error("initializeWasm() must be awaited first!");
17868 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
17869 // debug statements here
17871 // uintptr_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
17873 export function ChannelMonitorUpdate_clone_ptr(arg: number): number {
17874 if(!isWasmInitialized) {
17875 throw new Error("initializeWasm() must be awaited first!");
17877 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
17878 return nativeResponseValue;
17880 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
17882 export function ChannelMonitorUpdate_clone(orig: number): number {
17883 if(!isWasmInitialized) {
17884 throw new Error("initializeWasm() must be awaited first!");
17886 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
17887 return nativeResponseValue;
17889 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
17891 export function ChannelMonitorUpdate_write(obj: number): number {
17892 if(!isWasmInitialized) {
17893 throw new Error("initializeWasm() must be awaited first!");
17895 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
17896 return nativeResponseValue;
17898 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
17900 export function ChannelMonitorUpdate_read(ser: number): number {
17901 if(!isWasmInitialized) {
17902 throw new Error("initializeWasm() must be awaited first!");
17904 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
17905 return nativeResponseValue;
17907 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
17909 export function MonitorEvent_free(this_ptr: number): void {
17910 if(!isWasmInitialized) {
17911 throw new Error("initializeWasm() must be awaited first!");
17913 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
17914 // debug statements here
17916 // uintptr_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
17918 export function MonitorEvent_clone_ptr(arg: number): number {
17919 if(!isWasmInitialized) {
17920 throw new Error("initializeWasm() must be awaited first!");
17922 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
17923 return nativeResponseValue;
17925 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
17927 export function MonitorEvent_clone(orig: number): number {
17928 if(!isWasmInitialized) {
17929 throw new Error("initializeWasm() must be awaited first!");
17931 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
17932 return nativeResponseValue;
17934 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
17936 export function MonitorEvent_htlcevent(a: number): number {
17937 if(!isWasmInitialized) {
17938 throw new Error("initializeWasm() must be awaited first!");
17940 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
17941 return nativeResponseValue;
17943 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
17945 export function MonitorEvent_commitment_tx_confirmed(a: number): number {
17946 if(!isWasmInitialized) {
17947 throw new Error("initializeWasm() must be awaited first!");
17949 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
17950 return nativeResponseValue;
17952 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
17954 export function MonitorEvent_update_completed(funding_txo: number, monitor_update_id: bigint): number {
17955 if(!isWasmInitialized) {
17956 throw new Error("initializeWasm() must be awaited first!");
17958 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
17959 return nativeResponseValue;
17961 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
17963 export function MonitorEvent_update_failed(a: number): number {
17964 if(!isWasmInitialized) {
17965 throw new Error("initializeWasm() must be awaited first!");
17967 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
17968 return nativeResponseValue;
17970 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
17972 export function MonitorEvent_write(obj: number): number {
17973 if(!isWasmInitialized) {
17974 throw new Error("initializeWasm() must be awaited first!");
17976 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
17977 return nativeResponseValue;
17979 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
17981 export function MonitorEvent_read(ser: number): number {
17982 if(!isWasmInitialized) {
17983 throw new Error("initializeWasm() must be awaited first!");
17985 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
17986 return nativeResponseValue;
17988 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
17990 export function HTLCUpdate_free(this_obj: number): void {
17991 if(!isWasmInitialized) {
17992 throw new Error("initializeWasm() must be awaited first!");
17994 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
17995 // debug statements here
17997 // uintptr_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
17999 export function HTLCUpdate_clone_ptr(arg: number): number {
18000 if(!isWasmInitialized) {
18001 throw new Error("initializeWasm() must be awaited first!");
18003 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
18004 return nativeResponseValue;
18006 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
18008 export function HTLCUpdate_clone(orig: number): number {
18009 if(!isWasmInitialized) {
18010 throw new Error("initializeWasm() must be awaited first!");
18012 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
18013 return nativeResponseValue;
18015 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
18017 export function HTLCUpdate_write(obj: number): number {
18018 if(!isWasmInitialized) {
18019 throw new Error("initializeWasm() must be awaited first!");
18021 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
18022 return nativeResponseValue;
18024 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
18026 export function HTLCUpdate_read(ser: number): number {
18027 if(!isWasmInitialized) {
18028 throw new Error("initializeWasm() must be awaited first!");
18030 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
18031 return nativeResponseValue;
18033 // void Balance_free(struct LDKBalance this_ptr);
18035 export function Balance_free(this_ptr: number): void {
18036 if(!isWasmInitialized) {
18037 throw new Error("initializeWasm() must be awaited first!");
18039 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
18040 // debug statements here
18042 // uintptr_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
18044 export function Balance_clone_ptr(arg: number): number {
18045 if(!isWasmInitialized) {
18046 throw new Error("initializeWasm() must be awaited first!");
18048 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
18049 return nativeResponseValue;
18051 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
18053 export function Balance_clone(orig: number): number {
18054 if(!isWasmInitialized) {
18055 throw new Error("initializeWasm() must be awaited first!");
18057 const nativeResponseValue = wasm.TS_Balance_clone(orig);
18058 return nativeResponseValue;
18060 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
18062 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): number {
18063 if(!isWasmInitialized) {
18064 throw new Error("initializeWasm() must be awaited first!");
18066 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
18067 return nativeResponseValue;
18069 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
18071 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): number {
18072 if(!isWasmInitialized) {
18073 throw new Error("initializeWasm() must be awaited first!");
18075 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
18076 return nativeResponseValue;
18078 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
18080 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): number {
18081 if(!isWasmInitialized) {
18082 throw new Error("initializeWasm() must be awaited first!");
18084 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
18085 return nativeResponseValue;
18087 // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
18089 export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: bigint, claimable_height: number): number {
18090 if(!isWasmInitialized) {
18091 throw new Error("initializeWasm() must be awaited first!");
18093 const nativeResponseValue = wasm.TS_Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
18094 return nativeResponseValue;
18096 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
18098 export function Balance_eq(a: number, b: number): boolean {
18099 if(!isWasmInitialized) {
18100 throw new Error("initializeWasm() must be awaited first!");
18102 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
18103 return nativeResponseValue;
18105 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
18107 export function ChannelMonitor_free(this_obj: number): void {
18108 if(!isWasmInitialized) {
18109 throw new Error("initializeWasm() must be awaited first!");
18111 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
18112 // debug statements here
18114 // uintptr_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
18116 export function ChannelMonitor_clone_ptr(arg: number): number {
18117 if(!isWasmInitialized) {
18118 throw new Error("initializeWasm() must be awaited first!");
18120 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
18121 return nativeResponseValue;
18123 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
18125 export function ChannelMonitor_clone(orig: number): number {
18126 if(!isWasmInitialized) {
18127 throw new Error("initializeWasm() must be awaited first!");
18129 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
18130 return nativeResponseValue;
18132 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
18134 export function ChannelMonitor_write(obj: number): number {
18135 if(!isWasmInitialized) {
18136 throw new Error("initializeWasm() must be awaited first!");
18138 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
18139 return nativeResponseValue;
18141 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, struct LDKFeeEstimator fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
18143 export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
18144 if(!isWasmInitialized) {
18145 throw new Error("initializeWasm() must be awaited first!");
18147 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
18148 return nativeResponseValue;
18150 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18152 export function ChannelMonitor_get_latest_update_id(this_arg: number): bigint {
18153 if(!isWasmInitialized) {
18154 throw new Error("initializeWasm() must be awaited first!");
18156 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
18157 return nativeResponseValue;
18159 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18161 export function ChannelMonitor_get_funding_txo(this_arg: number): number {
18162 if(!isWasmInitialized) {
18163 throw new Error("initializeWasm() must be awaited first!");
18165 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
18166 return nativeResponseValue;
18168 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18170 export function ChannelMonitor_get_outputs_to_watch(this_arg: number): number {
18171 if(!isWasmInitialized) {
18172 throw new Error("initializeWasm() must be awaited first!");
18174 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
18175 return nativeResponseValue;
18177 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
18179 export function ChannelMonitor_load_outputs_to_watch(this_arg: number, filter: number): void {
18180 if(!isWasmInitialized) {
18181 throw new Error("initializeWasm() must be awaited first!");
18183 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
18184 // debug statements here
18186 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18188 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number {
18189 if(!isWasmInitialized) {
18190 throw new Error("initializeWasm() must be awaited first!");
18192 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
18193 return nativeResponseValue;
18195 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18197 export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number {
18198 if(!isWasmInitialized) {
18199 throw new Error("initializeWasm() must be awaited first!");
18201 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
18202 return nativeResponseValue;
18204 // MUST_USE_RES struct LDKPublicKey ChannelMonitor_get_counterparty_node_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18206 export function ChannelMonitor_get_counterparty_node_id(this_arg: number): number {
18207 if(!isWasmInitialized) {
18208 throw new Error("initializeWasm() must be awaited first!");
18210 const nativeResponseValue = wasm.TS_ChannelMonitor_get_counterparty_node_id(this_arg);
18211 return nativeResponseValue;
18213 // 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);
18215 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): number {
18216 if(!isWasmInitialized) {
18217 throw new Error("initializeWasm() must be awaited first!");
18219 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
18220 return nativeResponseValue;
18222 // 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);
18224 export function ChannelMonitor_block_connected(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
18225 if(!isWasmInitialized) {
18226 throw new Error("initializeWasm() must be awaited first!");
18228 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
18229 return nativeResponseValue;
18231 // 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);
18233 export function ChannelMonitor_block_disconnected(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
18234 if(!isWasmInitialized) {
18235 throw new Error("initializeWasm() must be awaited first!");
18237 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
18238 // debug statements here
18240 // 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);
18242 export function ChannelMonitor_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
18243 if(!isWasmInitialized) {
18244 throw new Error("initializeWasm() must be awaited first!");
18246 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
18247 return nativeResponseValue;
18249 // 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);
18251 export function ChannelMonitor_transaction_unconfirmed(this_arg: number, txid: number, broadcaster: number, fee_estimator: number, logger: number): void {
18252 if(!isWasmInitialized) {
18253 throw new Error("initializeWasm() must be awaited first!");
18255 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
18256 // debug statements here
18258 // 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);
18260 export function ChannelMonitor_best_block_updated(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
18261 if(!isWasmInitialized) {
18262 throw new Error("initializeWasm() must be awaited first!");
18264 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
18265 return nativeResponseValue;
18267 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18269 export function ChannelMonitor_get_relevant_txids(this_arg: number): number {
18270 if(!isWasmInitialized) {
18271 throw new Error("initializeWasm() must be awaited first!");
18273 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
18274 return nativeResponseValue;
18276 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18278 export function ChannelMonitor_current_best_block(this_arg: number): number {
18279 if(!isWasmInitialized) {
18280 throw new Error("initializeWasm() must be awaited first!");
18282 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
18283 return nativeResponseValue;
18285 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
18287 export function ChannelMonitor_get_claimable_balances(this_arg: number): number {
18288 if(!isWasmInitialized) {
18289 throw new Error("initializeWasm() must be awaited first!");
18291 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
18292 return nativeResponseValue;
18294 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
18296 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: number): number {
18297 if(!isWasmInitialized) {
18298 throw new Error("initializeWasm() must be awaited first!");
18300 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
18301 return nativeResponseValue;
18303 // void OutPoint_free(struct LDKOutPoint this_obj);
18305 export function OutPoint_free(this_obj: number): void {
18306 if(!isWasmInitialized) {
18307 throw new Error("initializeWasm() must be awaited first!");
18309 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
18310 // debug statements here
18312 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
18314 export function OutPoint_get_txid(this_ptr: number): number {
18315 if(!isWasmInitialized) {
18316 throw new Error("initializeWasm() must be awaited first!");
18318 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
18319 return nativeResponseValue;
18321 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18323 export function OutPoint_set_txid(this_ptr: number, val: number): void {
18324 if(!isWasmInitialized) {
18325 throw new Error("initializeWasm() must be awaited first!");
18327 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
18328 // debug statements here
18330 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
18332 export function OutPoint_get_index(this_ptr: number): number {
18333 if(!isWasmInitialized) {
18334 throw new Error("initializeWasm() must be awaited first!");
18336 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
18337 return nativeResponseValue;
18339 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
18341 export function OutPoint_set_index(this_ptr: number, val: number): void {
18342 if(!isWasmInitialized) {
18343 throw new Error("initializeWasm() must be awaited first!");
18345 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
18346 // debug statements here
18348 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
18350 export function OutPoint_new(txid_arg: number, index_arg: number): number {
18351 if(!isWasmInitialized) {
18352 throw new Error("initializeWasm() must be awaited first!");
18354 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
18355 return nativeResponseValue;
18357 // uintptr_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
18359 export function OutPoint_clone_ptr(arg: number): number {
18360 if(!isWasmInitialized) {
18361 throw new Error("initializeWasm() must be awaited first!");
18363 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
18364 return nativeResponseValue;
18366 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
18368 export function OutPoint_clone(orig: number): number {
18369 if(!isWasmInitialized) {
18370 throw new Error("initializeWasm() must be awaited first!");
18372 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
18373 return nativeResponseValue;
18375 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
18377 export function OutPoint_eq(a: number, b: number): boolean {
18378 if(!isWasmInitialized) {
18379 throw new Error("initializeWasm() must be awaited first!");
18381 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
18382 return nativeResponseValue;
18384 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
18386 export function OutPoint_hash(o: number): bigint {
18387 if(!isWasmInitialized) {
18388 throw new Error("initializeWasm() must be awaited first!");
18390 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
18391 return nativeResponseValue;
18393 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
18395 export function OutPoint_to_channel_id(this_arg: number): number {
18396 if(!isWasmInitialized) {
18397 throw new Error("initializeWasm() must be awaited first!");
18399 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
18400 return nativeResponseValue;
18402 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
18404 export function OutPoint_write(obj: number): number {
18405 if(!isWasmInitialized) {
18406 throw new Error("initializeWasm() must be awaited first!");
18408 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
18409 return nativeResponseValue;
18411 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
18413 export function OutPoint_read(ser: number): number {
18414 if(!isWasmInitialized) {
18415 throw new Error("initializeWasm() must be awaited first!");
18417 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
18418 return nativeResponseValue;
18420 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
18422 export function DelayedPaymentOutputDescriptor_free(this_obj: number): void {
18423 if(!isWasmInitialized) {
18424 throw new Error("initializeWasm() must be awaited first!");
18426 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
18427 // debug statements here
18429 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18431 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
18432 if(!isWasmInitialized) {
18433 throw new Error("initializeWasm() must be awaited first!");
18435 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
18436 return nativeResponseValue;
18438 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18440 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
18441 if(!isWasmInitialized) {
18442 throw new Error("initializeWasm() must be awaited first!");
18444 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
18445 // debug statements here
18447 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18449 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): number {
18450 if(!isWasmInitialized) {
18451 throw new Error("initializeWasm() must be awaited first!");
18453 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
18454 return nativeResponseValue;
18456 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18458 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: number, val: number): void {
18459 if(!isWasmInitialized) {
18460 throw new Error("initializeWasm() must be awaited first!");
18462 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
18463 // debug statements here
18465 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18467 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number {
18468 if(!isWasmInitialized) {
18469 throw new Error("initializeWasm() must be awaited first!");
18471 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
18472 return nativeResponseValue;
18474 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
18476 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: number, val: number): void {
18477 if(!isWasmInitialized) {
18478 throw new Error("initializeWasm() must be awaited first!");
18480 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
18481 // debug statements here
18483 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
18485 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
18486 if(!isWasmInitialized) {
18487 throw new Error("initializeWasm() must be awaited first!");
18489 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
18490 // debug statements here
18492 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18494 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): number {
18495 if(!isWasmInitialized) {
18496 throw new Error("initializeWasm() must be awaited first!");
18498 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
18499 return nativeResponseValue;
18501 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18503 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: number, val: number): void {
18504 if(!isWasmInitialized) {
18505 throw new Error("initializeWasm() must be awaited first!");
18507 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
18508 // debug statements here
18510 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
18512 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
18513 if(!isWasmInitialized) {
18514 throw new Error("initializeWasm() must be awaited first!");
18516 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
18517 return nativeResponseValue;
18519 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18521 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
18522 if(!isWasmInitialized) {
18523 throw new Error("initializeWasm() must be awaited first!");
18525 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
18526 // debug statements here
18528 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18530 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
18531 if(!isWasmInitialized) {
18532 throw new Error("initializeWasm() must be awaited first!");
18534 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
18535 return nativeResponseValue;
18537 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
18539 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18540 if(!isWasmInitialized) {
18541 throw new Error("initializeWasm() must be awaited first!");
18543 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
18544 // debug statements here
18546 // 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);
18548 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 {
18549 if(!isWasmInitialized) {
18550 throw new Error("initializeWasm() must be awaited first!");
18552 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);
18553 return nativeResponseValue;
18555 // uintptr_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
18557 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: number): number {
18558 if(!isWasmInitialized) {
18559 throw new Error("initializeWasm() must be awaited first!");
18561 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
18562 return nativeResponseValue;
18564 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
18566 export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
18567 if(!isWasmInitialized) {
18568 throw new Error("initializeWasm() must be awaited first!");
18570 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
18571 return nativeResponseValue;
18573 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
18575 export function DelayedPaymentOutputDescriptor_write(obj: number): number {
18576 if(!isWasmInitialized) {
18577 throw new Error("initializeWasm() must be awaited first!");
18579 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
18580 return nativeResponseValue;
18582 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
18584 export function DelayedPaymentOutputDescriptor_read(ser: number): number {
18585 if(!isWasmInitialized) {
18586 throw new Error("initializeWasm() must be awaited first!");
18588 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
18589 return nativeResponseValue;
18591 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
18593 export function StaticPaymentOutputDescriptor_free(this_obj: number): void {
18594 if(!isWasmInitialized) {
18595 throw new Error("initializeWasm() must be awaited first!");
18597 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
18598 // debug statements here
18600 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18602 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
18603 if(!isWasmInitialized) {
18604 throw new Error("initializeWasm() must be awaited first!");
18606 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
18607 return nativeResponseValue;
18609 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18611 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
18612 if(!isWasmInitialized) {
18613 throw new Error("initializeWasm() must be awaited first!");
18615 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
18616 // debug statements here
18618 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
18620 export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
18621 if(!isWasmInitialized) {
18622 throw new Error("initializeWasm() must be awaited first!");
18624 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
18625 // debug statements here
18627 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
18629 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
18630 if(!isWasmInitialized) {
18631 throw new Error("initializeWasm() must be awaited first!");
18633 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
18634 return nativeResponseValue;
18636 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18638 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
18639 if(!isWasmInitialized) {
18640 throw new Error("initializeWasm() must be awaited first!");
18642 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
18643 // debug statements here
18645 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18647 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
18648 if(!isWasmInitialized) {
18649 throw new Error("initializeWasm() must be awaited first!");
18651 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
18652 return nativeResponseValue;
18654 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
18656 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18657 if(!isWasmInitialized) {
18658 throw new Error("initializeWasm() must be awaited first!");
18660 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
18661 // debug statements here
18663 // 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);
18665 export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
18666 if(!isWasmInitialized) {
18667 throw new Error("initializeWasm() must be awaited first!");
18669 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
18670 return nativeResponseValue;
18672 // uintptr_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
18674 export function StaticPaymentOutputDescriptor_clone_ptr(arg: number): number {
18675 if(!isWasmInitialized) {
18676 throw new Error("initializeWasm() must be awaited first!");
18678 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
18679 return nativeResponseValue;
18681 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
18683 export function StaticPaymentOutputDescriptor_clone(orig: number): number {
18684 if(!isWasmInitialized) {
18685 throw new Error("initializeWasm() must be awaited first!");
18687 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
18688 return nativeResponseValue;
18690 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
18692 export function StaticPaymentOutputDescriptor_write(obj: number): number {
18693 if(!isWasmInitialized) {
18694 throw new Error("initializeWasm() must be awaited first!");
18696 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
18697 return nativeResponseValue;
18699 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
18701 export function StaticPaymentOutputDescriptor_read(ser: number): number {
18702 if(!isWasmInitialized) {
18703 throw new Error("initializeWasm() must be awaited first!");
18705 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
18706 return nativeResponseValue;
18708 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
18710 export function SpendableOutputDescriptor_free(this_ptr: number): void {
18711 if(!isWasmInitialized) {
18712 throw new Error("initializeWasm() must be awaited first!");
18714 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
18715 // debug statements here
18717 // uintptr_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
18719 export function SpendableOutputDescriptor_clone_ptr(arg: number): number {
18720 if(!isWasmInitialized) {
18721 throw new Error("initializeWasm() must be awaited first!");
18723 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
18724 return nativeResponseValue;
18726 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
18728 export function SpendableOutputDescriptor_clone(orig: number): number {
18729 if(!isWasmInitialized) {
18730 throw new Error("initializeWasm() must be awaited first!");
18732 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
18733 return nativeResponseValue;
18735 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
18737 export function SpendableOutputDescriptor_static_output(outpoint: number, output: number): number {
18738 if(!isWasmInitialized) {
18739 throw new Error("initializeWasm() must be awaited first!");
18741 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
18742 return nativeResponseValue;
18744 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
18746 export function SpendableOutputDescriptor_delayed_payment_output(a: number): number {
18747 if(!isWasmInitialized) {
18748 throw new Error("initializeWasm() must be awaited first!");
18750 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
18751 return nativeResponseValue;
18753 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
18755 export function SpendableOutputDescriptor_static_payment_output(a: number): number {
18756 if(!isWasmInitialized) {
18757 throw new Error("initializeWasm() must be awaited first!");
18759 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
18760 return nativeResponseValue;
18762 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
18764 export function SpendableOutputDescriptor_write(obj: number): number {
18765 if(!isWasmInitialized) {
18766 throw new Error("initializeWasm() must be awaited first!");
18768 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
18769 return nativeResponseValue;
18771 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
18773 export function SpendableOutputDescriptor_read(ser: number): number {
18774 if(!isWasmInitialized) {
18775 throw new Error("initializeWasm() must be awaited first!");
18777 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
18778 return nativeResponseValue;
18780 // void BaseSign_free(struct LDKBaseSign this_ptr);
18782 export function BaseSign_free(this_ptr: number): void {
18783 if(!isWasmInitialized) {
18784 throw new Error("initializeWasm() must be awaited first!");
18786 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
18787 // debug statements here
18789 // uintptr_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
18791 export function Sign_clone_ptr(arg: number): number {
18792 if(!isWasmInitialized) {
18793 throw new Error("initializeWasm() must be awaited first!");
18795 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
18796 return nativeResponseValue;
18798 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
18800 export function Sign_clone(orig: number): number {
18801 if(!isWasmInitialized) {
18802 throw new Error("initializeWasm() must be awaited first!");
18804 const nativeResponseValue = wasm.TS_Sign_clone(orig);
18805 return nativeResponseValue;
18807 // void Sign_free(struct LDKSign this_ptr);
18809 export function Sign_free(this_ptr: number): void {
18810 if(!isWasmInitialized) {
18811 throw new Error("initializeWasm() must be awaited first!");
18813 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
18814 // debug statements here
18816 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
18818 export function Recipient_clone(orig: number): Recipient {
18819 if(!isWasmInitialized) {
18820 throw new Error("initializeWasm() must be awaited first!");
18822 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
18823 return nativeResponseValue;
18825 // enum LDKRecipient Recipient_node(void);
18827 export function Recipient_node(): Recipient {
18828 if(!isWasmInitialized) {
18829 throw new Error("initializeWasm() must be awaited first!");
18831 const nativeResponseValue = wasm.TS_Recipient_node();
18832 return nativeResponseValue;
18834 // enum LDKRecipient Recipient_phantom_node(void);
18836 export function Recipient_phantom_node(): Recipient {
18837 if(!isWasmInitialized) {
18838 throw new Error("initializeWasm() must be awaited first!");
18840 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
18841 return nativeResponseValue;
18843 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
18845 export function KeysInterface_free(this_ptr: number): void {
18846 if(!isWasmInitialized) {
18847 throw new Error("initializeWasm() must be awaited first!");
18849 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
18850 // debug statements here
18852 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
18854 export function InMemorySigner_free(this_obj: number): void {
18855 if(!isWasmInitialized) {
18856 throw new Error("initializeWasm() must be awaited first!");
18858 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
18859 // debug statements here
18861 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18863 export function InMemorySigner_get_funding_key(this_ptr: number): number {
18864 if(!isWasmInitialized) {
18865 throw new Error("initializeWasm() must be awaited first!");
18867 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
18868 return nativeResponseValue;
18870 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18872 export function InMemorySigner_set_funding_key(this_ptr: number, val: number): void {
18873 if(!isWasmInitialized) {
18874 throw new Error("initializeWasm() must be awaited first!");
18876 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
18877 // debug statements here
18879 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18881 export function InMemorySigner_get_revocation_base_key(this_ptr: number): number {
18882 if(!isWasmInitialized) {
18883 throw new Error("initializeWasm() must be awaited first!");
18885 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
18886 return nativeResponseValue;
18888 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18890 export function InMemorySigner_set_revocation_base_key(this_ptr: number, val: number): void {
18891 if(!isWasmInitialized) {
18892 throw new Error("initializeWasm() must be awaited first!");
18894 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
18895 // debug statements here
18897 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18899 export function InMemorySigner_get_payment_key(this_ptr: number): number {
18900 if(!isWasmInitialized) {
18901 throw new Error("initializeWasm() must be awaited first!");
18903 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
18904 return nativeResponseValue;
18906 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18908 export function InMemorySigner_set_payment_key(this_ptr: number, val: number): void {
18909 if(!isWasmInitialized) {
18910 throw new Error("initializeWasm() must be awaited first!");
18912 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
18913 // debug statements here
18915 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18917 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): number {
18918 if(!isWasmInitialized) {
18919 throw new Error("initializeWasm() must be awaited first!");
18921 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
18922 return nativeResponseValue;
18924 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18926 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: number, val: number): void {
18927 if(!isWasmInitialized) {
18928 throw new Error("initializeWasm() must be awaited first!");
18930 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
18931 // debug statements here
18933 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18935 export function InMemorySigner_get_htlc_base_key(this_ptr: number): number {
18936 if(!isWasmInitialized) {
18937 throw new Error("initializeWasm() must be awaited first!");
18939 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
18940 return nativeResponseValue;
18942 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18944 export function InMemorySigner_set_htlc_base_key(this_ptr: number, val: number): void {
18945 if(!isWasmInitialized) {
18946 throw new Error("initializeWasm() must be awaited first!");
18948 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
18949 // debug statements here
18951 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18953 export function InMemorySigner_get_commitment_seed(this_ptr: number): number {
18954 if(!isWasmInitialized) {
18955 throw new Error("initializeWasm() must be awaited first!");
18957 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
18958 return nativeResponseValue;
18960 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18962 export function InMemorySigner_set_commitment_seed(this_ptr: number, val: number): void {
18963 if(!isWasmInitialized) {
18964 throw new Error("initializeWasm() must be awaited first!");
18966 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
18967 // debug statements here
18969 // uintptr_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
18971 export function InMemorySigner_clone_ptr(arg: number): number {
18972 if(!isWasmInitialized) {
18973 throw new Error("initializeWasm() must be awaited first!");
18975 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
18976 return nativeResponseValue;
18978 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
18980 export function InMemorySigner_clone(orig: number): number {
18981 if(!isWasmInitialized) {
18982 throw new Error("initializeWasm() must be awaited first!");
18984 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
18985 return nativeResponseValue;
18987 // 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);
18989 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 {
18990 if(!isWasmInitialized) {
18991 throw new Error("initializeWasm() must be awaited first!");
18993 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);
18994 return nativeResponseValue;
18996 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18998 export function InMemorySigner_counterparty_pubkeys(this_arg: number): number {
18999 if(!isWasmInitialized) {
19000 throw new Error("initializeWasm() must be awaited first!");
19002 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
19003 return nativeResponseValue;
19005 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19007 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number {
19008 if(!isWasmInitialized) {
19009 throw new Error("initializeWasm() must be awaited first!");
19011 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
19012 return nativeResponseValue;
19014 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19016 export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number {
19017 if(!isWasmInitialized) {
19018 throw new Error("initializeWasm() must be awaited first!");
19020 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
19021 return nativeResponseValue;
19023 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19025 export function InMemorySigner_is_outbound(this_arg: number): boolean {
19026 if(!isWasmInitialized) {
19027 throw new Error("initializeWasm() must be awaited first!");
19029 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
19030 return nativeResponseValue;
19032 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19034 export function InMemorySigner_funding_outpoint(this_arg: number): number {
19035 if(!isWasmInitialized) {
19036 throw new Error("initializeWasm() must be awaited first!");
19038 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
19039 return nativeResponseValue;
19041 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19043 export function InMemorySigner_get_channel_parameters(this_arg: number): number {
19044 if(!isWasmInitialized) {
19045 throw new Error("initializeWasm() must be awaited first!");
19047 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
19048 return nativeResponseValue;
19050 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19052 export function InMemorySigner_opt_anchors(this_arg: number): boolean {
19053 if(!isWasmInitialized) {
19054 throw new Error("initializeWasm() must be awaited first!");
19056 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
19057 return nativeResponseValue;
19059 // 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);
19061 export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
19062 if(!isWasmInitialized) {
19063 throw new Error("initializeWasm() must be awaited first!");
19065 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
19066 return nativeResponseValue;
19068 // 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);
19070 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
19071 if(!isWasmInitialized) {
19072 throw new Error("initializeWasm() must be awaited first!");
19074 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
19075 return nativeResponseValue;
19077 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19079 export function InMemorySigner_as_BaseSign(this_arg: number): number {
19080 if(!isWasmInitialized) {
19081 throw new Error("initializeWasm() must be awaited first!");
19083 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
19084 return nativeResponseValue;
19086 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
19088 export function InMemorySigner_as_Sign(this_arg: number): number {
19089 if(!isWasmInitialized) {
19090 throw new Error("initializeWasm() must be awaited first!");
19092 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
19093 return nativeResponseValue;
19095 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
19097 export function InMemorySigner_write(obj: number): number {
19098 if(!isWasmInitialized) {
19099 throw new Error("initializeWasm() must be awaited first!");
19101 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
19102 return nativeResponseValue;
19104 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
19106 export function InMemorySigner_read(ser: number, arg: number): number {
19107 if(!isWasmInitialized) {
19108 throw new Error("initializeWasm() must be awaited first!");
19110 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
19111 return nativeResponseValue;
19113 // void KeysManager_free(struct LDKKeysManager this_obj);
19115 export function KeysManager_free(this_obj: number): void {
19116 if(!isWasmInitialized) {
19117 throw new Error("initializeWasm() must be awaited first!");
19119 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
19120 // debug statements here
19122 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
19124 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): number {
19125 if(!isWasmInitialized) {
19126 throw new Error("initializeWasm() must be awaited first!");
19128 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
19129 return nativeResponseValue;
19131 // 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]);
19133 export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
19134 if(!isWasmInitialized) {
19135 throw new Error("initializeWasm() must be awaited first!");
19137 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
19138 return nativeResponseValue;
19140 // 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);
19142 export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
19143 if(!isWasmInitialized) {
19144 throw new Error("initializeWasm() must be awaited first!");
19146 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
19147 return nativeResponseValue;
19149 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
19151 export function KeysManager_as_KeysInterface(this_arg: number): number {
19152 if(!isWasmInitialized) {
19153 throw new Error("initializeWasm() must be awaited first!");
19155 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
19156 return nativeResponseValue;
19158 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
19160 export function PhantomKeysManager_free(this_obj: number): void {
19161 if(!isWasmInitialized) {
19162 throw new Error("initializeWasm() must be awaited first!");
19164 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
19165 // debug statements here
19167 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
19169 export function PhantomKeysManager_as_KeysInterface(this_arg: number): number {
19170 if(!isWasmInitialized) {
19171 throw new Error("initializeWasm() must be awaited first!");
19173 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
19174 return nativeResponseValue;
19176 // 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]);
19178 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): number {
19179 if(!isWasmInitialized) {
19180 throw new Error("initializeWasm() must be awaited first!");
19182 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
19183 return nativeResponseValue;
19185 // 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);
19187 export function PhantomKeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
19188 if(!isWasmInitialized) {
19189 throw new Error("initializeWasm() must be awaited first!");
19191 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
19192 return nativeResponseValue;
19194 // 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]);
19196 export function PhantomKeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
19197 if(!isWasmInitialized) {
19198 throw new Error("initializeWasm() must be awaited first!");
19200 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
19201 return nativeResponseValue;
19203 // void ChannelManager_free(struct LDKChannelManager this_obj);
19205 export function ChannelManager_free(this_obj: number): void {
19206 if(!isWasmInitialized) {
19207 throw new Error("initializeWasm() must be awaited first!");
19209 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
19210 // debug statements here
19212 // void ChainParameters_free(struct LDKChainParameters this_obj);
19214 export function ChainParameters_free(this_obj: number): void {
19215 if(!isWasmInitialized) {
19216 throw new Error("initializeWasm() must be awaited first!");
19218 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
19219 // debug statements here
19221 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
19223 export function ChainParameters_get_network(this_ptr: number): Network {
19224 if(!isWasmInitialized) {
19225 throw new Error("initializeWasm() must be awaited first!");
19227 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
19228 return nativeResponseValue;
19230 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
19232 export function ChainParameters_set_network(this_ptr: number, val: Network): void {
19233 if(!isWasmInitialized) {
19234 throw new Error("initializeWasm() must be awaited first!");
19236 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
19237 // debug statements here
19239 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
19241 export function ChainParameters_get_best_block(this_ptr: number): number {
19242 if(!isWasmInitialized) {
19243 throw new Error("initializeWasm() must be awaited first!");
19245 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
19246 return nativeResponseValue;
19248 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
19250 export function ChainParameters_set_best_block(this_ptr: number, val: number): void {
19251 if(!isWasmInitialized) {
19252 throw new Error("initializeWasm() must be awaited first!");
19254 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
19255 // debug statements here
19257 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
19259 export function ChainParameters_new(network_arg: Network, best_block_arg: number): number {
19260 if(!isWasmInitialized) {
19261 throw new Error("initializeWasm() must be awaited first!");
19263 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
19264 return nativeResponseValue;
19266 // uintptr_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
19268 export function ChainParameters_clone_ptr(arg: number): number {
19269 if(!isWasmInitialized) {
19270 throw new Error("initializeWasm() must be awaited first!");
19272 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
19273 return nativeResponseValue;
19275 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
19277 export function ChainParameters_clone(orig: number): number {
19278 if(!isWasmInitialized) {
19279 throw new Error("initializeWasm() must be awaited first!");
19281 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
19282 return nativeResponseValue;
19284 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
19286 export function CounterpartyForwardingInfo_free(this_obj: number): void {
19287 if(!isWasmInitialized) {
19288 throw new Error("initializeWasm() must be awaited first!");
19290 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
19291 // debug statements here
19293 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
19295 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: number): number {
19296 if(!isWasmInitialized) {
19297 throw new Error("initializeWasm() must be awaited first!");
19299 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
19300 return nativeResponseValue;
19302 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
19304 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: number, val: number): void {
19305 if(!isWasmInitialized) {
19306 throw new Error("initializeWasm() must be awaited first!");
19308 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
19309 // debug statements here
19311 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
19313 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: number): number {
19314 if(!isWasmInitialized) {
19315 throw new Error("initializeWasm() must be awaited first!");
19317 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
19318 return nativeResponseValue;
19320 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
19322 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: number, val: number): void {
19323 if(!isWasmInitialized) {
19324 throw new Error("initializeWasm() must be awaited first!");
19326 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
19327 // debug statements here
19329 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
19331 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: number): number {
19332 if(!isWasmInitialized) {
19333 throw new Error("initializeWasm() must be awaited first!");
19335 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
19336 return nativeResponseValue;
19338 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
19340 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
19341 if(!isWasmInitialized) {
19342 throw new Error("initializeWasm() must be awaited first!");
19344 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
19345 // debug statements here
19347 // 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);
19349 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): number {
19350 if(!isWasmInitialized) {
19351 throw new Error("initializeWasm() must be awaited first!");
19353 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
19354 return nativeResponseValue;
19356 // uintptr_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
19358 export function CounterpartyForwardingInfo_clone_ptr(arg: number): number {
19359 if(!isWasmInitialized) {
19360 throw new Error("initializeWasm() must be awaited first!");
19362 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
19363 return nativeResponseValue;
19365 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
19367 export function CounterpartyForwardingInfo_clone(orig: number): number {
19368 if(!isWasmInitialized) {
19369 throw new Error("initializeWasm() must be awaited first!");
19371 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
19372 return nativeResponseValue;
19374 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
19376 export function ChannelCounterparty_free(this_obj: number): void {
19377 if(!isWasmInitialized) {
19378 throw new Error("initializeWasm() must be awaited first!");
19380 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
19381 // debug statements here
19383 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19385 export function ChannelCounterparty_get_node_id(this_ptr: number): number {
19386 if(!isWasmInitialized) {
19387 throw new Error("initializeWasm() must be awaited first!");
19389 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
19390 return nativeResponseValue;
19392 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19394 export function ChannelCounterparty_set_node_id(this_ptr: number, val: number): void {
19395 if(!isWasmInitialized) {
19396 throw new Error("initializeWasm() must be awaited first!");
19398 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
19399 // debug statements here
19401 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19403 export function ChannelCounterparty_get_features(this_ptr: number): number {
19404 if(!isWasmInitialized) {
19405 throw new Error("initializeWasm() must be awaited first!");
19407 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
19408 return nativeResponseValue;
19410 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
19412 export function ChannelCounterparty_set_features(this_ptr: number, val: number): void {
19413 if(!isWasmInitialized) {
19414 throw new Error("initializeWasm() must be awaited first!");
19416 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
19417 // debug statements here
19419 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19421 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: number): bigint {
19422 if(!isWasmInitialized) {
19423 throw new Error("initializeWasm() must be awaited first!");
19425 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
19426 return nativeResponseValue;
19428 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
19430 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: number, val: bigint): void {
19431 if(!isWasmInitialized) {
19432 throw new Error("initializeWasm() must be awaited first!");
19434 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
19435 // debug statements here
19437 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19439 export function ChannelCounterparty_get_forwarding_info(this_ptr: number): number {
19440 if(!isWasmInitialized) {
19441 throw new Error("initializeWasm() must be awaited first!");
19443 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
19444 return nativeResponseValue;
19446 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
19448 export function ChannelCounterparty_set_forwarding_info(this_ptr: number, val: number): void {
19449 if(!isWasmInitialized) {
19450 throw new Error("initializeWasm() must be awaited first!");
19452 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
19453 // debug statements here
19455 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19457 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: number): number {
19458 if(!isWasmInitialized) {
19459 throw new Error("initializeWasm() must be awaited first!");
19461 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
19462 return nativeResponseValue;
19464 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19466 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: number, val: number): void {
19467 if(!isWasmInitialized) {
19468 throw new Error("initializeWasm() must be awaited first!");
19470 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
19471 // debug statements here
19473 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19475 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: number): number {
19476 if(!isWasmInitialized) {
19477 throw new Error("initializeWasm() must be awaited first!");
19479 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
19480 return nativeResponseValue;
19482 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19484 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: number, val: number): void {
19485 if(!isWasmInitialized) {
19486 throw new Error("initializeWasm() must be awaited first!");
19488 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
19489 // debug statements here
19491 // 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);
19493 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 {
19494 if(!isWasmInitialized) {
19495 throw new Error("initializeWasm() must be awaited first!");
19497 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);
19498 return nativeResponseValue;
19500 // uintptr_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
19502 export function ChannelCounterparty_clone_ptr(arg: number): number {
19503 if(!isWasmInitialized) {
19504 throw new Error("initializeWasm() must be awaited first!");
19506 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
19507 return nativeResponseValue;
19509 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
19511 export function ChannelCounterparty_clone(orig: number): number {
19512 if(!isWasmInitialized) {
19513 throw new Error("initializeWasm() must be awaited first!");
19515 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
19516 return nativeResponseValue;
19518 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
19520 export function ChannelDetails_free(this_obj: number): void {
19521 if(!isWasmInitialized) {
19522 throw new Error("initializeWasm() must be awaited first!");
19524 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
19525 // debug statements here
19527 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
19529 export function ChannelDetails_get_channel_id(this_ptr: number): number {
19530 if(!isWasmInitialized) {
19531 throw new Error("initializeWasm() must be awaited first!");
19533 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
19534 return nativeResponseValue;
19536 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19538 export function ChannelDetails_set_channel_id(this_ptr: number, val: number): void {
19539 if(!isWasmInitialized) {
19540 throw new Error("initializeWasm() must be awaited first!");
19542 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
19543 // debug statements here
19545 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19547 export function ChannelDetails_get_counterparty(this_ptr: number): number {
19548 if(!isWasmInitialized) {
19549 throw new Error("initializeWasm() must be awaited first!");
19551 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
19552 return nativeResponseValue;
19554 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
19556 export function ChannelDetails_set_counterparty(this_ptr: number, val: number): void {
19557 if(!isWasmInitialized) {
19558 throw new Error("initializeWasm() must be awaited first!");
19560 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
19561 // debug statements here
19563 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19565 export function ChannelDetails_get_funding_txo(this_ptr: number): number {
19566 if(!isWasmInitialized) {
19567 throw new Error("initializeWasm() must be awaited first!");
19569 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
19570 return nativeResponseValue;
19572 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
19574 export function ChannelDetails_set_funding_txo(this_ptr: number, val: number): void {
19575 if(!isWasmInitialized) {
19576 throw new Error("initializeWasm() must be awaited first!");
19578 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
19579 // debug statements here
19581 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19583 export function ChannelDetails_get_channel_type(this_ptr: number): number {
19584 if(!isWasmInitialized) {
19585 throw new Error("initializeWasm() must be awaited first!");
19587 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
19588 return nativeResponseValue;
19590 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
19592 export function ChannelDetails_set_channel_type(this_ptr: number, val: number): void {
19593 if(!isWasmInitialized) {
19594 throw new Error("initializeWasm() must be awaited first!");
19596 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
19597 // debug statements here
19599 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19601 export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
19602 if(!isWasmInitialized) {
19603 throw new Error("initializeWasm() must be awaited first!");
19605 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
19606 return nativeResponseValue;
19608 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19610 export function ChannelDetails_set_short_channel_id(this_ptr: number, val: number): void {
19611 if(!isWasmInitialized) {
19612 throw new Error("initializeWasm() must be awaited first!");
19614 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
19615 // debug statements here
19617 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19619 export function ChannelDetails_get_outbound_scid_alias(this_ptr: number): number {
19620 if(!isWasmInitialized) {
19621 throw new Error("initializeWasm() must be awaited first!");
19623 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
19624 return nativeResponseValue;
19626 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19628 export function ChannelDetails_set_outbound_scid_alias(this_ptr: number, val: number): void {
19629 if(!isWasmInitialized) {
19630 throw new Error("initializeWasm() must be awaited first!");
19632 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
19633 // debug statements here
19635 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19637 export function ChannelDetails_get_inbound_scid_alias(this_ptr: number): number {
19638 if(!isWasmInitialized) {
19639 throw new Error("initializeWasm() must be awaited first!");
19641 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
19642 return nativeResponseValue;
19644 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19646 export function ChannelDetails_set_inbound_scid_alias(this_ptr: number, val: number): void {
19647 if(!isWasmInitialized) {
19648 throw new Error("initializeWasm() must be awaited first!");
19650 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
19651 // debug statements here
19653 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19655 export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): bigint {
19656 if(!isWasmInitialized) {
19657 throw new Error("initializeWasm() must be awaited first!");
19659 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
19660 return nativeResponseValue;
19662 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19664 export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
19665 if(!isWasmInitialized) {
19666 throw new Error("initializeWasm() must be awaited first!");
19668 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
19669 // debug statements here
19671 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19673 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: number): number {
19674 if(!isWasmInitialized) {
19675 throw new Error("initializeWasm() must be awaited first!");
19677 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
19678 return nativeResponseValue;
19680 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19682 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: number, val: number): void {
19683 if(!isWasmInitialized) {
19684 throw new Error("initializeWasm() must be awaited first!");
19686 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
19687 // debug statements here
19689 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19691 export function ChannelDetails_get_user_channel_id(this_ptr: number): bigint {
19692 if(!isWasmInitialized) {
19693 throw new Error("initializeWasm() must be awaited first!");
19695 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
19696 return nativeResponseValue;
19698 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19700 export function ChannelDetails_set_user_channel_id(this_ptr: number, val: bigint): void {
19701 if(!isWasmInitialized) {
19702 throw new Error("initializeWasm() must be awaited first!");
19704 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
19705 // debug statements here
19707 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19709 export function ChannelDetails_get_balance_msat(this_ptr: number): bigint {
19710 if(!isWasmInitialized) {
19711 throw new Error("initializeWasm() must be awaited first!");
19713 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
19714 return nativeResponseValue;
19716 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19718 export function ChannelDetails_set_balance_msat(this_ptr: number, val: bigint): void {
19719 if(!isWasmInitialized) {
19720 throw new Error("initializeWasm() must be awaited first!");
19722 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
19723 // debug statements here
19725 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19727 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: number): bigint {
19728 if(!isWasmInitialized) {
19729 throw new Error("initializeWasm() must be awaited first!");
19731 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
19732 return nativeResponseValue;
19734 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19736 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: number, val: bigint): void {
19737 if(!isWasmInitialized) {
19738 throw new Error("initializeWasm() must be awaited first!");
19740 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
19741 // debug statements here
19743 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19745 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: number): bigint {
19746 if(!isWasmInitialized) {
19747 throw new Error("initializeWasm() must be awaited first!");
19749 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
19750 return nativeResponseValue;
19752 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19754 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: number, val: bigint): void {
19755 if(!isWasmInitialized) {
19756 throw new Error("initializeWasm() must be awaited first!");
19758 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
19759 // debug statements here
19761 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19763 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: number): bigint {
19764 if(!isWasmInitialized) {
19765 throw new Error("initializeWasm() must be awaited first!");
19767 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
19768 return nativeResponseValue;
19770 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19772 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: number, val: bigint): void {
19773 if(!isWasmInitialized) {
19774 throw new Error("initializeWasm() must be awaited first!");
19776 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
19777 // debug statements here
19779 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19781 export function ChannelDetails_get_confirmations_required(this_ptr: number): number {
19782 if(!isWasmInitialized) {
19783 throw new Error("initializeWasm() must be awaited first!");
19785 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
19786 return nativeResponseValue;
19788 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
19790 export function ChannelDetails_set_confirmations_required(this_ptr: number, val: number): void {
19791 if(!isWasmInitialized) {
19792 throw new Error("initializeWasm() must be awaited first!");
19794 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
19795 // debug statements here
19797 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19799 export function ChannelDetails_get_force_close_spend_delay(this_ptr: number): number {
19800 if(!isWasmInitialized) {
19801 throw new Error("initializeWasm() must be awaited first!");
19803 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
19804 return nativeResponseValue;
19806 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
19808 export function ChannelDetails_set_force_close_spend_delay(this_ptr: number, val: number): void {
19809 if(!isWasmInitialized) {
19810 throw new Error("initializeWasm() must be awaited first!");
19812 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
19813 // debug statements here
19815 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19817 export function ChannelDetails_get_is_outbound(this_ptr: number): boolean {
19818 if(!isWasmInitialized) {
19819 throw new Error("initializeWasm() must be awaited first!");
19821 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
19822 return nativeResponseValue;
19824 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19826 export function ChannelDetails_set_is_outbound(this_ptr: number, val: boolean): void {
19827 if(!isWasmInitialized) {
19828 throw new Error("initializeWasm() must be awaited first!");
19830 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
19831 // debug statements here
19833 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19835 export function ChannelDetails_get_is_channel_ready(this_ptr: number): boolean {
19836 if(!isWasmInitialized) {
19837 throw new Error("initializeWasm() must be awaited first!");
19839 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
19840 return nativeResponseValue;
19842 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19844 export function ChannelDetails_set_is_channel_ready(this_ptr: number, val: boolean): void {
19845 if(!isWasmInitialized) {
19846 throw new Error("initializeWasm() must be awaited first!");
19848 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
19849 // debug statements here
19851 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19853 export function ChannelDetails_get_is_usable(this_ptr: number): boolean {
19854 if(!isWasmInitialized) {
19855 throw new Error("initializeWasm() must be awaited first!");
19857 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
19858 return nativeResponseValue;
19860 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19862 export function ChannelDetails_set_is_usable(this_ptr: number, val: boolean): void {
19863 if(!isWasmInitialized) {
19864 throw new Error("initializeWasm() must be awaited first!");
19866 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
19867 // debug statements here
19869 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19871 export function ChannelDetails_get_is_public(this_ptr: number): boolean {
19872 if(!isWasmInitialized) {
19873 throw new Error("initializeWasm() must be awaited first!");
19875 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
19876 return nativeResponseValue;
19878 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19880 export function ChannelDetails_set_is_public(this_ptr: number, val: boolean): void {
19881 if(!isWasmInitialized) {
19882 throw new Error("initializeWasm() must be awaited first!");
19884 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
19885 // debug statements here
19887 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19889 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: number): number {
19890 if(!isWasmInitialized) {
19891 throw new Error("initializeWasm() must be awaited first!");
19893 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
19894 return nativeResponseValue;
19896 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19898 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: number, val: number): void {
19899 if(!isWasmInitialized) {
19900 throw new Error("initializeWasm() must be awaited first!");
19902 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
19903 // debug statements here
19905 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19907 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: number): number {
19908 if(!isWasmInitialized) {
19909 throw new Error("initializeWasm() must be awaited first!");
19911 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
19912 return nativeResponseValue;
19914 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19916 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: number, val: number): void {
19917 if(!isWasmInitialized) {
19918 throw new Error("initializeWasm() must be awaited first!");
19920 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
19921 // debug statements here
19923 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19925 export function ChannelDetails_get_config(this_ptr: number): number {
19926 if(!isWasmInitialized) {
19927 throw new Error("initializeWasm() must be awaited first!");
19929 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
19930 return nativeResponseValue;
19932 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
19934 export function ChannelDetails_set_config(this_ptr: number, val: number): void {
19935 if(!isWasmInitialized) {
19936 throw new Error("initializeWasm() must be awaited first!");
19938 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
19939 // debug statements here
19941 // 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);
19943 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 {
19944 if(!isWasmInitialized) {
19945 throw new Error("initializeWasm() must be awaited first!");
19947 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);
19948 return nativeResponseValue;
19950 // uintptr_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
19952 export function ChannelDetails_clone_ptr(arg: number): number {
19953 if(!isWasmInitialized) {
19954 throw new Error("initializeWasm() must be awaited first!");
19956 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
19957 return nativeResponseValue;
19959 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
19961 export function ChannelDetails_clone(orig: number): number {
19962 if(!isWasmInitialized) {
19963 throw new Error("initializeWasm() must be awaited first!");
19965 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
19966 return nativeResponseValue;
19968 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
19970 export function ChannelDetails_get_inbound_payment_scid(this_arg: number): number {
19971 if(!isWasmInitialized) {
19972 throw new Error("initializeWasm() must be awaited first!");
19974 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
19975 return nativeResponseValue;
19977 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
19979 export function ChannelDetails_get_outbound_payment_scid(this_arg: number): number {
19980 if(!isWasmInitialized) {
19981 throw new Error("initializeWasm() must be awaited first!");
19983 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
19984 return nativeResponseValue;
19986 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
19988 export function PaymentSendFailure_free(this_ptr: number): void {
19989 if(!isWasmInitialized) {
19990 throw new Error("initializeWasm() must be awaited first!");
19992 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
19993 // debug statements here
19995 // uintptr_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
19997 export function PaymentSendFailure_clone_ptr(arg: number): number {
19998 if(!isWasmInitialized) {
19999 throw new Error("initializeWasm() must be awaited first!");
20001 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
20002 return nativeResponseValue;
20004 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
20006 export function PaymentSendFailure_clone(orig: number): number {
20007 if(!isWasmInitialized) {
20008 throw new Error("initializeWasm() must be awaited first!");
20010 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
20011 return nativeResponseValue;
20013 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
20015 export function PaymentSendFailure_parameter_error(a: number): number {
20016 if(!isWasmInitialized) {
20017 throw new Error("initializeWasm() must be awaited first!");
20019 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
20020 return nativeResponseValue;
20022 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
20024 export function PaymentSendFailure_path_parameter_error(a: number): number {
20025 if(!isWasmInitialized) {
20026 throw new Error("initializeWasm() must be awaited first!");
20028 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
20029 return nativeResponseValue;
20031 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
20033 export function PaymentSendFailure_all_failed_retry_safe(a: number): number {
20034 if(!isWasmInitialized) {
20035 throw new Error("initializeWasm() must be awaited first!");
20037 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
20038 return nativeResponseValue;
20040 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
20042 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: number, payment_id: number): number {
20043 if(!isWasmInitialized) {
20044 throw new Error("initializeWasm() must be awaited first!");
20046 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
20047 return nativeResponseValue;
20049 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
20051 export function PhantomRouteHints_free(this_obj: number): void {
20052 if(!isWasmInitialized) {
20053 throw new Error("initializeWasm() must be awaited first!");
20055 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
20056 // debug statements here
20058 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
20060 export function PhantomRouteHints_get_channels(this_ptr: number): number {
20061 if(!isWasmInitialized) {
20062 throw new Error("initializeWasm() must be awaited first!");
20064 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
20065 return nativeResponseValue;
20067 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
20069 export function PhantomRouteHints_set_channels(this_ptr: number, val: number): void {
20070 if(!isWasmInitialized) {
20071 throw new Error("initializeWasm() must be awaited first!");
20073 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
20074 // debug statements here
20076 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
20078 export function PhantomRouteHints_get_phantom_scid(this_ptr: number): bigint {
20079 if(!isWasmInitialized) {
20080 throw new Error("initializeWasm() must be awaited first!");
20082 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
20083 return nativeResponseValue;
20085 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
20087 export function PhantomRouteHints_set_phantom_scid(this_ptr: number, val: bigint): void {
20088 if(!isWasmInitialized) {
20089 throw new Error("initializeWasm() must be awaited first!");
20091 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
20092 // debug statements here
20094 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
20096 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: number): number {
20097 if(!isWasmInitialized) {
20098 throw new Error("initializeWasm() must be awaited first!");
20100 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
20101 return nativeResponseValue;
20103 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20105 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: number, val: number): void {
20106 if(!isWasmInitialized) {
20107 throw new Error("initializeWasm() must be awaited first!");
20109 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
20110 // debug statements here
20112 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
20114 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): number {
20115 if(!isWasmInitialized) {
20116 throw new Error("initializeWasm() must be awaited first!");
20118 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
20119 return nativeResponseValue;
20121 // uintptr_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
20123 export function PhantomRouteHints_clone_ptr(arg: number): number {
20124 if(!isWasmInitialized) {
20125 throw new Error("initializeWasm() must be awaited first!");
20127 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
20128 return nativeResponseValue;
20130 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
20132 export function PhantomRouteHints_clone(orig: number): number {
20133 if(!isWasmInitialized) {
20134 throw new Error("initializeWasm() must be awaited first!");
20136 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
20137 return nativeResponseValue;
20139 // 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);
20141 export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
20142 if(!isWasmInitialized) {
20143 throw new Error("initializeWasm() must be awaited first!");
20145 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
20146 return nativeResponseValue;
20148 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
20150 export function ChannelManager_get_current_default_configuration(this_arg: number): number {
20151 if(!isWasmInitialized) {
20152 throw new Error("initializeWasm() must be awaited first!");
20154 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
20155 return nativeResponseValue;
20157 // 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);
20159 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 {
20160 if(!isWasmInitialized) {
20161 throw new Error("initializeWasm() must be awaited first!");
20163 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
20164 return nativeResponseValue;
20166 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
20168 export function ChannelManager_list_channels(this_arg: number): number {
20169 if(!isWasmInitialized) {
20170 throw new Error("initializeWasm() must be awaited first!");
20172 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
20173 return nativeResponseValue;
20175 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
20177 export function ChannelManager_list_usable_channels(this_arg: number): number {
20178 if(!isWasmInitialized) {
20179 throw new Error("initializeWasm() must be awaited first!");
20181 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
20182 return nativeResponseValue;
20184 // 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);
20186 export function ChannelManager_close_channel(this_arg: number, channel_id: number, counterparty_node_id: number): number {
20187 if(!isWasmInitialized) {
20188 throw new Error("initializeWasm() must be awaited first!");
20190 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
20191 return nativeResponseValue;
20193 // 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);
20195 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 {
20196 if(!isWasmInitialized) {
20197 throw new Error("initializeWasm() must be awaited first!");
20199 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight);
20200 return nativeResponseValue;
20202 // 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);
20204 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: number, channel_id: number, counterparty_node_id: number): number {
20205 if(!isWasmInitialized) {
20206 throw new Error("initializeWasm() must be awaited first!");
20208 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
20209 return nativeResponseValue;
20211 // 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);
20213 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: number, channel_id: number, counterparty_node_id: number): number {
20214 if(!isWasmInitialized) {
20215 throw new Error("initializeWasm() must be awaited first!");
20217 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
20218 return nativeResponseValue;
20220 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
20222 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: number): void {
20223 if(!isWasmInitialized) {
20224 throw new Error("initializeWasm() must be awaited first!");
20226 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
20227 // debug statements here
20229 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
20231 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: number): void {
20232 if(!isWasmInitialized) {
20233 throw new Error("initializeWasm() must be awaited first!");
20235 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
20236 // debug statements here
20238 // 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);
20240 export function ChannelManager_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
20241 if(!isWasmInitialized) {
20242 throw new Error("initializeWasm() must be awaited first!");
20244 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
20245 return nativeResponseValue;
20247 // 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);
20249 export function ChannelManager_retry_payment(this_arg: number, route: number, payment_id: number): number {
20250 if(!isWasmInitialized) {
20251 throw new Error("initializeWasm() must be awaited first!");
20253 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
20254 return nativeResponseValue;
20256 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
20258 export function ChannelManager_abandon_payment(this_arg: number, payment_id: number): void {
20259 if(!isWasmInitialized) {
20260 throw new Error("initializeWasm() must be awaited first!");
20262 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
20263 // debug statements here
20265 // 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);
20267 export function ChannelManager_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
20268 if(!isWasmInitialized) {
20269 throw new Error("initializeWasm() must be awaited first!");
20271 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
20272 return nativeResponseValue;
20274 // MUST_USE_RES struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ ChannelManager_send_probe(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ hops);
20276 export function ChannelManager_send_probe(this_arg: number, hops: number): number {
20277 if(!isWasmInitialized) {
20278 throw new Error("initializeWasm() must be awaited first!");
20280 const nativeResponseValue = wasm.TS_ChannelManager_send_probe(this_arg, hops);
20281 return nativeResponseValue;
20283 // 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);
20285 export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): number {
20286 if(!isWasmInitialized) {
20287 throw new Error("initializeWasm() must be awaited first!");
20289 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
20290 return nativeResponseValue;
20292 // void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
20294 export function ChannelManager_broadcast_node_announcement(this_arg: number, rgb: number, alias: number, addresses: number): void {
20295 if(!isWasmInitialized) {
20296 throw new Error("initializeWasm() must be awaited first!");
20298 const nativeResponseValue = wasm.TS_ChannelManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
20299 // debug statements here
20301 // 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);
20303 export function ChannelManager_update_channel_config(this_arg: number, counterparty_node_id: number, channel_ids: number, config: number): number {
20304 if(!isWasmInitialized) {
20305 throw new Error("initializeWasm() must be awaited first!");
20307 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
20308 return nativeResponseValue;
20310 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
20312 export function ChannelManager_process_pending_htlc_forwards(this_arg: number): void {
20313 if(!isWasmInitialized) {
20314 throw new Error("initializeWasm() must be awaited first!");
20316 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
20317 // debug statements here
20319 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
20321 export function ChannelManager_timer_tick_occurred(this_arg: number): void {
20322 if(!isWasmInitialized) {
20323 throw new Error("initializeWasm() must be awaited first!");
20325 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
20326 // debug statements here
20328 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
20330 export function ChannelManager_fail_htlc_backwards(this_arg: number, payment_hash: number): void {
20331 if(!isWasmInitialized) {
20332 throw new Error("initializeWasm() must be awaited first!");
20334 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
20335 // debug statements here
20337 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
20339 export function ChannelManager_claim_funds(this_arg: number, payment_preimage: number): void {
20340 if(!isWasmInitialized) {
20341 throw new Error("initializeWasm() must be awaited first!");
20343 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
20344 // debug statements here
20346 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
20348 export function ChannelManager_get_our_node_id(this_arg: number): number {
20349 if(!isWasmInitialized) {
20350 throw new Error("initializeWasm() must be awaited first!");
20352 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
20353 return nativeResponseValue;
20355 // 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);
20357 export function ChannelManager_accept_inbound_channel(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): number {
20358 if(!isWasmInitialized) {
20359 throw new Error("initializeWasm() must be awaited first!");
20361 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
20362 return nativeResponseValue;
20364 // 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);
20366 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 {
20367 if(!isWasmInitialized) {
20368 throw new Error("initializeWasm() must be awaited first!");
20370 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
20371 return nativeResponseValue;
20373 // 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);
20375 export function ChannelManager_create_inbound_payment(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
20376 if(!isWasmInitialized) {
20377 throw new Error("initializeWasm() must be awaited first!");
20379 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
20380 return nativeResponseValue;
20382 // 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);
20384 export function ChannelManager_create_inbound_payment_legacy(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
20385 if(!isWasmInitialized) {
20386 throw new Error("initializeWasm() must be awaited first!");
20388 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
20389 return nativeResponseValue;
20391 // 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);
20393 export function ChannelManager_create_inbound_payment_for_hash(this_arg: number, payment_hash: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
20394 if(!isWasmInitialized) {
20395 throw new Error("initializeWasm() must be awaited first!");
20397 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
20398 return nativeResponseValue;
20400 // 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);
20402 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 {
20403 if(!isWasmInitialized) {
20404 throw new Error("initializeWasm() must be awaited first!");
20406 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
20407 return nativeResponseValue;
20409 // 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);
20411 export function ChannelManager_get_payment_preimage(this_arg: number, payment_hash: number, payment_secret: number): number {
20412 if(!isWasmInitialized) {
20413 throw new Error("initializeWasm() must be awaited first!");
20415 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
20416 return nativeResponseValue;
20418 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
20420 export function ChannelManager_get_phantom_scid(this_arg: number): bigint {
20421 if(!isWasmInitialized) {
20422 throw new Error("initializeWasm() must be awaited first!");
20424 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
20425 return nativeResponseValue;
20427 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
20429 export function ChannelManager_get_phantom_route_hints(this_arg: number): number {
20430 if(!isWasmInitialized) {
20431 throw new Error("initializeWasm() must be awaited first!");
20433 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
20434 return nativeResponseValue;
20436 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
20438 export function ChannelManager_as_MessageSendEventsProvider(this_arg: number): number {
20439 if(!isWasmInitialized) {
20440 throw new Error("initializeWasm() must be awaited first!");
20442 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
20443 return nativeResponseValue;
20445 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
20447 export function ChannelManager_as_EventsProvider(this_arg: number): number {
20448 if(!isWasmInitialized) {
20449 throw new Error("initializeWasm() must be awaited first!");
20451 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
20452 return nativeResponseValue;
20454 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
20456 export function ChannelManager_as_Listen(this_arg: number): number {
20457 if(!isWasmInitialized) {
20458 throw new Error("initializeWasm() must be awaited first!");
20460 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
20461 return nativeResponseValue;
20463 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
20465 export function ChannelManager_as_Confirm(this_arg: number): number {
20466 if(!isWasmInitialized) {
20467 throw new Error("initializeWasm() must be awaited first!");
20469 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
20470 return nativeResponseValue;
20472 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
20474 export function ChannelManager_await_persistable_update(this_arg: number): void {
20475 if(!isWasmInitialized) {
20476 throw new Error("initializeWasm() must be awaited first!");
20478 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
20479 // debug statements here
20481 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
20483 export function ChannelManager_current_best_block(this_arg: number): number {
20484 if(!isWasmInitialized) {
20485 throw new Error("initializeWasm() must be awaited first!");
20487 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
20488 return nativeResponseValue;
20490 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
20492 export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number {
20493 if(!isWasmInitialized) {
20494 throw new Error("initializeWasm() must be awaited first!");
20496 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
20497 return nativeResponseValue;
20499 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
20501 export function CounterpartyForwardingInfo_write(obj: number): number {
20502 if(!isWasmInitialized) {
20503 throw new Error("initializeWasm() must be awaited first!");
20505 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
20506 return nativeResponseValue;
20508 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
20510 export function CounterpartyForwardingInfo_read(ser: number): number {
20511 if(!isWasmInitialized) {
20512 throw new Error("initializeWasm() must be awaited first!");
20514 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
20515 return nativeResponseValue;
20517 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
20519 export function ChannelCounterparty_write(obj: number): number {
20520 if(!isWasmInitialized) {
20521 throw new Error("initializeWasm() must be awaited first!");
20523 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
20524 return nativeResponseValue;
20526 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
20528 export function ChannelCounterparty_read(ser: number): number {
20529 if(!isWasmInitialized) {
20530 throw new Error("initializeWasm() must be awaited first!");
20532 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
20533 return nativeResponseValue;
20535 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
20537 export function ChannelDetails_write(obj: number): number {
20538 if(!isWasmInitialized) {
20539 throw new Error("initializeWasm() must be awaited first!");
20541 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
20542 return nativeResponseValue;
20544 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
20546 export function ChannelDetails_read(ser: number): number {
20547 if(!isWasmInitialized) {
20548 throw new Error("initializeWasm() must be awaited first!");
20550 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
20551 return nativeResponseValue;
20553 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
20555 export function PhantomRouteHints_write(obj: number): number {
20556 if(!isWasmInitialized) {
20557 throw new Error("initializeWasm() must be awaited first!");
20559 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
20560 return nativeResponseValue;
20562 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
20564 export function PhantomRouteHints_read(ser: number): number {
20565 if(!isWasmInitialized) {
20566 throw new Error("initializeWasm() must be awaited first!");
20568 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
20569 return nativeResponseValue;
20571 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
20573 export function ChannelManager_write(obj: number): number {
20574 if(!isWasmInitialized) {
20575 throw new Error("initializeWasm() must be awaited first!");
20577 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
20578 return nativeResponseValue;
20580 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
20582 export function ChannelManagerReadArgs_free(this_obj: number): void {
20583 if(!isWasmInitialized) {
20584 throw new Error("initializeWasm() must be awaited first!");
20586 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
20587 // debug statements here
20589 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20591 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: number): number {
20592 if(!isWasmInitialized) {
20593 throw new Error("initializeWasm() must be awaited first!");
20595 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
20596 return nativeResponseValue;
20598 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
20600 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: number, val: number): void {
20601 if(!isWasmInitialized) {
20602 throw new Error("initializeWasm() must be awaited first!");
20604 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
20605 // debug statements here
20607 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20609 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: number): number {
20610 if(!isWasmInitialized) {
20611 throw new Error("initializeWasm() must be awaited first!");
20613 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
20614 return nativeResponseValue;
20616 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
20618 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: number, val: number): void {
20619 if(!isWasmInitialized) {
20620 throw new Error("initializeWasm() must be awaited first!");
20622 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
20623 // debug statements here
20625 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20627 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: number): number {
20628 if(!isWasmInitialized) {
20629 throw new Error("initializeWasm() must be awaited first!");
20631 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
20632 return nativeResponseValue;
20634 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
20636 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: number, val: number): void {
20637 if(!isWasmInitialized) {
20638 throw new Error("initializeWasm() must be awaited first!");
20640 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
20641 // debug statements here
20643 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20645 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: number): number {
20646 if(!isWasmInitialized) {
20647 throw new Error("initializeWasm() must be awaited first!");
20649 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
20650 return nativeResponseValue;
20652 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
20654 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: number, val: number): void {
20655 if(!isWasmInitialized) {
20656 throw new Error("initializeWasm() must be awaited first!");
20658 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
20659 // debug statements here
20661 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20663 export function ChannelManagerReadArgs_get_logger(this_ptr: number): number {
20664 if(!isWasmInitialized) {
20665 throw new Error("initializeWasm() must be awaited first!");
20667 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
20668 return nativeResponseValue;
20670 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
20672 export function ChannelManagerReadArgs_set_logger(this_ptr: number, val: number): void {
20673 if(!isWasmInitialized) {
20674 throw new Error("initializeWasm() must be awaited first!");
20676 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
20677 // debug statements here
20679 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20681 export function ChannelManagerReadArgs_get_default_config(this_ptr: number): number {
20682 if(!isWasmInitialized) {
20683 throw new Error("initializeWasm() must be awaited first!");
20685 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
20686 return nativeResponseValue;
20688 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
20690 export function ChannelManagerReadArgs_set_default_config(this_ptr: number, val: number): void {
20691 if(!isWasmInitialized) {
20692 throw new Error("initializeWasm() must be awaited first!");
20694 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
20695 // debug statements here
20697 // 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);
20699 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 {
20700 if(!isWasmInitialized) {
20701 throw new Error("initializeWasm() must be awaited first!");
20703 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
20704 return nativeResponseValue;
20706 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
20708 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: number): number {
20709 if(!isWasmInitialized) {
20710 throw new Error("initializeWasm() must be awaited first!");
20712 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
20713 return nativeResponseValue;
20715 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
20717 export function ExpandedKey_free(this_obj: number): void {
20718 if(!isWasmInitialized) {
20719 throw new Error("initializeWasm() must be awaited first!");
20721 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
20722 // debug statements here
20724 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
20726 export function ExpandedKey_new(key_material: number): number {
20727 if(!isWasmInitialized) {
20728 throw new Error("initializeWasm() must be awaited first!");
20730 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
20731 return nativeResponseValue;
20733 // 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);
20735 export function create(keys: number, min_value_msat: number, invoice_expiry_delta_secs: number, keys_manager: number, current_time: bigint): number {
20736 if(!isWasmInitialized) {
20737 throw new Error("initializeWasm() must be awaited first!");
20739 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, keys_manager, current_time);
20740 return nativeResponseValue;
20742 // 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);
20744 export function create_from_hash(keys: number, min_value_msat: number, payment_hash: number, invoice_expiry_delta_secs: number, current_time: bigint): number {
20745 if(!isWasmInitialized) {
20746 throw new Error("initializeWasm() must be awaited first!");
20748 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time);
20749 return nativeResponseValue;
20751 // void DecodeError_free(struct LDKDecodeError this_obj);
20753 export function DecodeError_free(this_obj: number): void {
20754 if(!isWasmInitialized) {
20755 throw new Error("initializeWasm() must be awaited first!");
20757 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
20758 // debug statements here
20760 // uintptr_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
20762 export function DecodeError_clone_ptr(arg: number): number {
20763 if(!isWasmInitialized) {
20764 throw new Error("initializeWasm() must be awaited first!");
20766 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
20767 return nativeResponseValue;
20769 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
20771 export function DecodeError_clone(orig: number): number {
20772 if(!isWasmInitialized) {
20773 throw new Error("initializeWasm() must be awaited first!");
20775 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
20776 return nativeResponseValue;
20778 // void Init_free(struct LDKInit this_obj);
20780 export function Init_free(this_obj: number): void {
20781 if(!isWasmInitialized) {
20782 throw new Error("initializeWasm() must be awaited first!");
20784 const nativeResponseValue = wasm.TS_Init_free(this_obj);
20785 // debug statements here
20787 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
20789 export function Init_get_features(this_ptr: number): number {
20790 if(!isWasmInitialized) {
20791 throw new Error("initializeWasm() must be awaited first!");
20793 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
20794 return nativeResponseValue;
20796 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
20798 export function Init_set_features(this_ptr: number, val: number): void {
20799 if(!isWasmInitialized) {
20800 throw new Error("initializeWasm() must be awaited first!");
20802 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
20803 // debug statements here
20805 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
20807 export function Init_get_remote_network_address(this_ptr: number): number {
20808 if(!isWasmInitialized) {
20809 throw new Error("initializeWasm() must be awaited first!");
20811 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
20812 return nativeResponseValue;
20814 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
20816 export function Init_set_remote_network_address(this_ptr: number, val: number): void {
20817 if(!isWasmInitialized) {
20818 throw new Error("initializeWasm() must be awaited first!");
20820 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
20821 // debug statements here
20823 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
20825 export function Init_new(features_arg: number, remote_network_address_arg: number): number {
20826 if(!isWasmInitialized) {
20827 throw new Error("initializeWasm() must be awaited first!");
20829 const nativeResponseValue = wasm.TS_Init_new(features_arg, remote_network_address_arg);
20830 return nativeResponseValue;
20832 // uintptr_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
20834 export function Init_clone_ptr(arg: number): number {
20835 if(!isWasmInitialized) {
20836 throw new Error("initializeWasm() must be awaited first!");
20838 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
20839 return nativeResponseValue;
20841 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
20843 export function Init_clone(orig: number): number {
20844 if(!isWasmInitialized) {
20845 throw new Error("initializeWasm() must be awaited first!");
20847 const nativeResponseValue = wasm.TS_Init_clone(orig);
20848 return nativeResponseValue;
20850 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
20852 export function ErrorMessage_free(this_obj: number): void {
20853 if(!isWasmInitialized) {
20854 throw new Error("initializeWasm() must be awaited first!");
20856 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
20857 // debug statements here
20859 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
20861 export function ErrorMessage_get_channel_id(this_ptr: number): number {
20862 if(!isWasmInitialized) {
20863 throw new Error("initializeWasm() must be awaited first!");
20865 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
20866 return nativeResponseValue;
20868 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20870 export function ErrorMessage_set_channel_id(this_ptr: number, val: number): void {
20871 if(!isWasmInitialized) {
20872 throw new Error("initializeWasm() must be awaited first!");
20874 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
20875 // debug statements here
20877 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
20879 export function ErrorMessage_get_data(this_ptr: number): number {
20880 if(!isWasmInitialized) {
20881 throw new Error("initializeWasm() must be awaited first!");
20883 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
20884 return nativeResponseValue;
20886 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20888 export function ErrorMessage_set_data(this_ptr: number, val: number): void {
20889 if(!isWasmInitialized) {
20890 throw new Error("initializeWasm() must be awaited first!");
20892 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
20893 // debug statements here
20895 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
20897 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): number {
20898 if(!isWasmInitialized) {
20899 throw new Error("initializeWasm() must be awaited first!");
20901 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
20902 return nativeResponseValue;
20904 // uintptr_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
20906 export function ErrorMessage_clone_ptr(arg: number): number {
20907 if(!isWasmInitialized) {
20908 throw new Error("initializeWasm() must be awaited first!");
20910 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
20911 return nativeResponseValue;
20913 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
20915 export function ErrorMessage_clone(orig: number): number {
20916 if(!isWasmInitialized) {
20917 throw new Error("initializeWasm() must be awaited first!");
20919 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
20920 return nativeResponseValue;
20922 // void WarningMessage_free(struct LDKWarningMessage this_obj);
20924 export function WarningMessage_free(this_obj: number): void {
20925 if(!isWasmInitialized) {
20926 throw new Error("initializeWasm() must be awaited first!");
20928 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
20929 // debug statements here
20931 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
20933 export function WarningMessage_get_channel_id(this_ptr: number): number {
20934 if(!isWasmInitialized) {
20935 throw new Error("initializeWasm() must be awaited first!");
20937 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
20938 return nativeResponseValue;
20940 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20942 export function WarningMessage_set_channel_id(this_ptr: number, val: number): void {
20943 if(!isWasmInitialized) {
20944 throw new Error("initializeWasm() must be awaited first!");
20946 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
20947 // debug statements here
20949 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
20951 export function WarningMessage_get_data(this_ptr: number): number {
20952 if(!isWasmInitialized) {
20953 throw new Error("initializeWasm() must be awaited first!");
20955 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
20956 return nativeResponseValue;
20958 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20960 export function WarningMessage_set_data(this_ptr: number, val: number): void {
20961 if(!isWasmInitialized) {
20962 throw new Error("initializeWasm() must be awaited first!");
20964 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
20965 // debug statements here
20967 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
20969 export function WarningMessage_new(channel_id_arg: number, data_arg: number): number {
20970 if(!isWasmInitialized) {
20971 throw new Error("initializeWasm() must be awaited first!");
20973 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
20974 return nativeResponseValue;
20976 // uintptr_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
20978 export function WarningMessage_clone_ptr(arg: number): number {
20979 if(!isWasmInitialized) {
20980 throw new Error("initializeWasm() must be awaited first!");
20982 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
20983 return nativeResponseValue;
20985 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
20987 export function WarningMessage_clone(orig: number): number {
20988 if(!isWasmInitialized) {
20989 throw new Error("initializeWasm() must be awaited first!");
20991 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
20992 return nativeResponseValue;
20994 // void Ping_free(struct LDKPing this_obj);
20996 export function Ping_free(this_obj: number): void {
20997 if(!isWasmInitialized) {
20998 throw new Error("initializeWasm() must be awaited first!");
21000 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
21001 // debug statements here
21003 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
21005 export function Ping_get_ponglen(this_ptr: number): number {
21006 if(!isWasmInitialized) {
21007 throw new Error("initializeWasm() must be awaited first!");
21009 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
21010 return nativeResponseValue;
21012 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
21014 export function Ping_set_ponglen(this_ptr: number, val: number): void {
21015 if(!isWasmInitialized) {
21016 throw new Error("initializeWasm() must be awaited first!");
21018 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
21019 // debug statements here
21021 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
21023 export function Ping_get_byteslen(this_ptr: number): number {
21024 if(!isWasmInitialized) {
21025 throw new Error("initializeWasm() must be awaited first!");
21027 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
21028 return nativeResponseValue;
21030 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
21032 export function Ping_set_byteslen(this_ptr: number, val: number): void {
21033 if(!isWasmInitialized) {
21034 throw new Error("initializeWasm() must be awaited first!");
21036 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
21037 // debug statements here
21039 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
21041 export function Ping_new(ponglen_arg: number, byteslen_arg: number): number {
21042 if(!isWasmInitialized) {
21043 throw new Error("initializeWasm() must be awaited first!");
21045 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
21046 return nativeResponseValue;
21048 // uintptr_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
21050 export function Ping_clone_ptr(arg: number): number {
21051 if(!isWasmInitialized) {
21052 throw new Error("initializeWasm() must be awaited first!");
21054 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
21055 return nativeResponseValue;
21057 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
21059 export function Ping_clone(orig: number): number {
21060 if(!isWasmInitialized) {
21061 throw new Error("initializeWasm() must be awaited first!");
21063 const nativeResponseValue = wasm.TS_Ping_clone(orig);
21064 return nativeResponseValue;
21066 // void Pong_free(struct LDKPong this_obj);
21068 export function Pong_free(this_obj: number): void {
21069 if(!isWasmInitialized) {
21070 throw new Error("initializeWasm() must be awaited first!");
21072 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
21073 // debug statements here
21075 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
21077 export function Pong_get_byteslen(this_ptr: number): number {
21078 if(!isWasmInitialized) {
21079 throw new Error("initializeWasm() must be awaited first!");
21081 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
21082 return nativeResponseValue;
21084 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
21086 export function Pong_set_byteslen(this_ptr: number, val: number): void {
21087 if(!isWasmInitialized) {
21088 throw new Error("initializeWasm() must be awaited first!");
21090 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
21091 // debug statements here
21093 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
21095 export function Pong_new(byteslen_arg: number): number {
21096 if(!isWasmInitialized) {
21097 throw new Error("initializeWasm() must be awaited first!");
21099 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
21100 return nativeResponseValue;
21102 // uintptr_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
21104 export function Pong_clone_ptr(arg: number): number {
21105 if(!isWasmInitialized) {
21106 throw new Error("initializeWasm() must be awaited first!");
21108 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
21109 return nativeResponseValue;
21111 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
21113 export function Pong_clone(orig: number): number {
21114 if(!isWasmInitialized) {
21115 throw new Error("initializeWasm() must be awaited first!");
21117 const nativeResponseValue = wasm.TS_Pong_clone(orig);
21118 return nativeResponseValue;
21120 // void OpenChannel_free(struct LDKOpenChannel this_obj);
21122 export function OpenChannel_free(this_obj: number): void {
21123 if(!isWasmInitialized) {
21124 throw new Error("initializeWasm() must be awaited first!");
21126 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
21127 // debug statements here
21129 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
21131 export function OpenChannel_get_chain_hash(this_ptr: number): number {
21132 if(!isWasmInitialized) {
21133 throw new Error("initializeWasm() must be awaited first!");
21135 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
21136 return nativeResponseValue;
21138 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21140 export function OpenChannel_set_chain_hash(this_ptr: number, val: number): void {
21141 if(!isWasmInitialized) {
21142 throw new Error("initializeWasm() must be awaited first!");
21144 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
21145 // debug statements here
21147 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
21149 export function OpenChannel_get_temporary_channel_id(this_ptr: number): number {
21150 if(!isWasmInitialized) {
21151 throw new Error("initializeWasm() must be awaited first!");
21153 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
21154 return nativeResponseValue;
21156 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21158 export function OpenChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
21159 if(!isWasmInitialized) {
21160 throw new Error("initializeWasm() must be awaited first!");
21162 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
21163 // debug statements here
21165 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21167 export function OpenChannel_get_funding_satoshis(this_ptr: number): bigint {
21168 if(!isWasmInitialized) {
21169 throw new Error("initializeWasm() must be awaited first!");
21171 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
21172 return nativeResponseValue;
21174 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21176 export function OpenChannel_set_funding_satoshis(this_ptr: number, val: bigint): void {
21177 if(!isWasmInitialized) {
21178 throw new Error("initializeWasm() must be awaited first!");
21180 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
21181 // debug statements here
21183 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21185 export function OpenChannel_get_push_msat(this_ptr: number): bigint {
21186 if(!isWasmInitialized) {
21187 throw new Error("initializeWasm() must be awaited first!");
21189 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
21190 return nativeResponseValue;
21192 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21194 export function OpenChannel_set_push_msat(this_ptr: number, val: bigint): void {
21195 if(!isWasmInitialized) {
21196 throw new Error("initializeWasm() must be awaited first!");
21198 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
21199 // debug statements here
21201 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21203 export function OpenChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
21204 if(!isWasmInitialized) {
21205 throw new Error("initializeWasm() must be awaited first!");
21207 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
21208 return nativeResponseValue;
21210 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21212 export function OpenChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
21213 if(!isWasmInitialized) {
21214 throw new Error("initializeWasm() must be awaited first!");
21216 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
21217 // debug statements here
21219 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21221 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
21222 if(!isWasmInitialized) {
21223 throw new Error("initializeWasm() must be awaited first!");
21225 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
21226 return nativeResponseValue;
21228 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21230 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
21231 if(!isWasmInitialized) {
21232 throw new Error("initializeWasm() must be awaited first!");
21234 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
21235 // debug statements here
21237 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21239 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
21240 if(!isWasmInitialized) {
21241 throw new Error("initializeWasm() must be awaited first!");
21243 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
21244 return nativeResponseValue;
21246 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21248 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
21249 if(!isWasmInitialized) {
21250 throw new Error("initializeWasm() must be awaited first!");
21252 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
21253 // debug statements here
21255 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21257 export function OpenChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
21258 if(!isWasmInitialized) {
21259 throw new Error("initializeWasm() must be awaited first!");
21261 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
21262 return nativeResponseValue;
21264 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
21266 export function OpenChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
21267 if(!isWasmInitialized) {
21268 throw new Error("initializeWasm() must be awaited first!");
21270 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
21271 // debug statements here
21273 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21275 export function OpenChannel_get_feerate_per_kw(this_ptr: number): number {
21276 if(!isWasmInitialized) {
21277 throw new Error("initializeWasm() must be awaited first!");
21279 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
21280 return nativeResponseValue;
21282 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
21284 export function OpenChannel_set_feerate_per_kw(this_ptr: number, val: number): void {
21285 if(!isWasmInitialized) {
21286 throw new Error("initializeWasm() must be awaited first!");
21288 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
21289 // debug statements here
21291 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21293 export function OpenChannel_get_to_self_delay(this_ptr: number): number {
21294 if(!isWasmInitialized) {
21295 throw new Error("initializeWasm() must be awaited first!");
21297 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
21298 return nativeResponseValue;
21300 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
21302 export function OpenChannel_set_to_self_delay(this_ptr: number, val: number): void {
21303 if(!isWasmInitialized) {
21304 throw new Error("initializeWasm() must be awaited first!");
21306 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
21307 // debug statements here
21309 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21311 export function OpenChannel_get_max_accepted_htlcs(this_ptr: number): number {
21312 if(!isWasmInitialized) {
21313 throw new Error("initializeWasm() must be awaited first!");
21315 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
21316 return nativeResponseValue;
21318 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
21320 export function OpenChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
21321 if(!isWasmInitialized) {
21322 throw new Error("initializeWasm() must be awaited first!");
21324 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
21325 // debug statements here
21327 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21329 export function OpenChannel_get_funding_pubkey(this_ptr: number): number {
21330 if(!isWasmInitialized) {
21331 throw new Error("initializeWasm() must be awaited first!");
21333 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
21334 return nativeResponseValue;
21336 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21338 export function OpenChannel_set_funding_pubkey(this_ptr: number, val: number): void {
21339 if(!isWasmInitialized) {
21340 throw new Error("initializeWasm() must be awaited first!");
21342 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
21343 // debug statements here
21345 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21347 export function OpenChannel_get_revocation_basepoint(this_ptr: number): number {
21348 if(!isWasmInitialized) {
21349 throw new Error("initializeWasm() must be awaited first!");
21351 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
21352 return nativeResponseValue;
21354 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21356 export function OpenChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
21357 if(!isWasmInitialized) {
21358 throw new Error("initializeWasm() must be awaited first!");
21360 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
21361 // debug statements here
21363 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21365 export function OpenChannel_get_payment_point(this_ptr: number): number {
21366 if(!isWasmInitialized) {
21367 throw new Error("initializeWasm() must be awaited first!");
21369 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
21370 return nativeResponseValue;
21372 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21374 export function OpenChannel_set_payment_point(this_ptr: number, val: number): void {
21375 if(!isWasmInitialized) {
21376 throw new Error("initializeWasm() must be awaited first!");
21378 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
21379 // debug statements here
21381 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21383 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: number): number {
21384 if(!isWasmInitialized) {
21385 throw new Error("initializeWasm() must be awaited first!");
21387 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
21388 return nativeResponseValue;
21390 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21392 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
21393 if(!isWasmInitialized) {
21394 throw new Error("initializeWasm() must be awaited first!");
21396 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
21397 // debug statements here
21399 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21401 export function OpenChannel_get_htlc_basepoint(this_ptr: number): number {
21402 if(!isWasmInitialized) {
21403 throw new Error("initializeWasm() must be awaited first!");
21405 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
21406 return nativeResponseValue;
21408 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21410 export function OpenChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
21411 if(!isWasmInitialized) {
21412 throw new Error("initializeWasm() must be awaited first!");
21414 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
21415 // debug statements here
21417 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21419 export function OpenChannel_get_first_per_commitment_point(this_ptr: number): number {
21420 if(!isWasmInitialized) {
21421 throw new Error("initializeWasm() must be awaited first!");
21423 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
21424 return nativeResponseValue;
21426 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21428 export function OpenChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
21429 if(!isWasmInitialized) {
21430 throw new Error("initializeWasm() must be awaited first!");
21432 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
21433 // debug statements here
21435 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21437 export function OpenChannel_get_channel_flags(this_ptr: number): number {
21438 if(!isWasmInitialized) {
21439 throw new Error("initializeWasm() must be awaited first!");
21441 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
21442 return nativeResponseValue;
21444 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
21446 export function OpenChannel_set_channel_flags(this_ptr: number, val: number): void {
21447 if(!isWasmInitialized) {
21448 throw new Error("initializeWasm() must be awaited first!");
21450 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
21451 // debug statements here
21453 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
21455 export function OpenChannel_get_channel_type(this_ptr: number): number {
21456 if(!isWasmInitialized) {
21457 throw new Error("initializeWasm() must be awaited first!");
21459 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
21460 return nativeResponseValue;
21462 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
21464 export function OpenChannel_set_channel_type(this_ptr: number, val: number): void {
21465 if(!isWasmInitialized) {
21466 throw new Error("initializeWasm() must be awaited first!");
21468 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
21469 // debug statements here
21471 // uintptr_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
21473 export function OpenChannel_clone_ptr(arg: number): number {
21474 if(!isWasmInitialized) {
21475 throw new Error("initializeWasm() must be awaited first!");
21477 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
21478 return nativeResponseValue;
21480 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
21482 export function OpenChannel_clone(orig: number): number {
21483 if(!isWasmInitialized) {
21484 throw new Error("initializeWasm() must be awaited first!");
21486 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
21487 return nativeResponseValue;
21489 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
21491 export function AcceptChannel_free(this_obj: number): void {
21492 if(!isWasmInitialized) {
21493 throw new Error("initializeWasm() must be awaited first!");
21495 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
21496 // debug statements here
21498 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
21500 export function AcceptChannel_get_temporary_channel_id(this_ptr: number): number {
21501 if(!isWasmInitialized) {
21502 throw new Error("initializeWasm() must be awaited first!");
21504 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
21505 return nativeResponseValue;
21507 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21509 export function AcceptChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
21510 if(!isWasmInitialized) {
21511 throw new Error("initializeWasm() must be awaited first!");
21513 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
21514 // debug statements here
21516 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21518 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
21519 if(!isWasmInitialized) {
21520 throw new Error("initializeWasm() must be awaited first!");
21522 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
21523 return nativeResponseValue;
21525 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21527 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
21528 if(!isWasmInitialized) {
21529 throw new Error("initializeWasm() must be awaited first!");
21531 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
21532 // debug statements here
21534 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21536 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
21537 if(!isWasmInitialized) {
21538 throw new Error("initializeWasm() must be awaited first!");
21540 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
21541 return nativeResponseValue;
21543 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21545 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
21546 if(!isWasmInitialized) {
21547 throw new Error("initializeWasm() must be awaited first!");
21549 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
21550 // debug statements here
21552 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21554 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
21555 if(!isWasmInitialized) {
21556 throw new Error("initializeWasm() must be awaited first!");
21558 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
21559 return nativeResponseValue;
21561 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21563 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
21564 if(!isWasmInitialized) {
21565 throw new Error("initializeWasm() must be awaited first!");
21567 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
21568 // debug statements here
21570 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21572 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
21573 if(!isWasmInitialized) {
21574 throw new Error("initializeWasm() must be awaited first!");
21576 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
21577 return nativeResponseValue;
21579 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21581 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
21582 if(!isWasmInitialized) {
21583 throw new Error("initializeWasm() must be awaited first!");
21585 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
21586 // debug statements here
21588 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21590 export function AcceptChannel_get_minimum_depth(this_ptr: number): number {
21591 if(!isWasmInitialized) {
21592 throw new Error("initializeWasm() must be awaited first!");
21594 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
21595 return nativeResponseValue;
21597 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
21599 export function AcceptChannel_set_minimum_depth(this_ptr: number, val: number): void {
21600 if(!isWasmInitialized) {
21601 throw new Error("initializeWasm() must be awaited first!");
21603 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
21604 // debug statements here
21606 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21608 export function AcceptChannel_get_to_self_delay(this_ptr: number): number {
21609 if(!isWasmInitialized) {
21610 throw new Error("initializeWasm() must be awaited first!");
21612 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
21613 return nativeResponseValue;
21615 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
21617 export function AcceptChannel_set_to_self_delay(this_ptr: number, val: number): void {
21618 if(!isWasmInitialized) {
21619 throw new Error("initializeWasm() must be awaited first!");
21621 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
21622 // debug statements here
21624 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21626 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: number): number {
21627 if(!isWasmInitialized) {
21628 throw new Error("initializeWasm() must be awaited first!");
21630 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
21631 return nativeResponseValue;
21633 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
21635 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
21636 if(!isWasmInitialized) {
21637 throw new Error("initializeWasm() must be awaited first!");
21639 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
21640 // debug statements here
21642 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21644 export function AcceptChannel_get_funding_pubkey(this_ptr: number): number {
21645 if(!isWasmInitialized) {
21646 throw new Error("initializeWasm() must be awaited first!");
21648 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
21649 return nativeResponseValue;
21651 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21653 export function AcceptChannel_set_funding_pubkey(this_ptr: number, val: number): void {
21654 if(!isWasmInitialized) {
21655 throw new Error("initializeWasm() must be awaited first!");
21657 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
21658 // debug statements here
21660 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21662 export function AcceptChannel_get_revocation_basepoint(this_ptr: number): number {
21663 if(!isWasmInitialized) {
21664 throw new Error("initializeWasm() must be awaited first!");
21666 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
21667 return nativeResponseValue;
21669 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21671 export function AcceptChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
21672 if(!isWasmInitialized) {
21673 throw new Error("initializeWasm() must be awaited first!");
21675 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
21676 // debug statements here
21678 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21680 export function AcceptChannel_get_payment_point(this_ptr: number): number {
21681 if(!isWasmInitialized) {
21682 throw new Error("initializeWasm() must be awaited first!");
21684 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
21685 return nativeResponseValue;
21687 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21689 export function AcceptChannel_set_payment_point(this_ptr: number, val: number): void {
21690 if(!isWasmInitialized) {
21691 throw new Error("initializeWasm() must be awaited first!");
21693 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
21694 // debug statements here
21696 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21698 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: number): number {
21699 if(!isWasmInitialized) {
21700 throw new Error("initializeWasm() must be awaited first!");
21702 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
21703 return nativeResponseValue;
21705 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21707 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
21708 if(!isWasmInitialized) {
21709 throw new Error("initializeWasm() must be awaited first!");
21711 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
21712 // debug statements here
21714 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21716 export function AcceptChannel_get_htlc_basepoint(this_ptr: number): number {
21717 if(!isWasmInitialized) {
21718 throw new Error("initializeWasm() must be awaited first!");
21720 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
21721 return nativeResponseValue;
21723 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21725 export function AcceptChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
21726 if(!isWasmInitialized) {
21727 throw new Error("initializeWasm() must be awaited first!");
21729 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
21730 // debug statements here
21732 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21734 export function AcceptChannel_get_first_per_commitment_point(this_ptr: number): number {
21735 if(!isWasmInitialized) {
21736 throw new Error("initializeWasm() must be awaited first!");
21738 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
21739 return nativeResponseValue;
21741 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21743 export function AcceptChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
21744 if(!isWasmInitialized) {
21745 throw new Error("initializeWasm() must be awaited first!");
21747 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
21748 // debug statements here
21750 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21752 export function AcceptChannel_get_channel_type(this_ptr: number): number {
21753 if(!isWasmInitialized) {
21754 throw new Error("initializeWasm() must be awaited first!");
21756 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
21757 return nativeResponseValue;
21759 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
21761 export function AcceptChannel_set_channel_type(this_ptr: number, val: number): void {
21762 if(!isWasmInitialized) {
21763 throw new Error("initializeWasm() must be awaited first!");
21765 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
21766 // debug statements here
21768 // uintptr_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
21770 export function AcceptChannel_clone_ptr(arg: number): number {
21771 if(!isWasmInitialized) {
21772 throw new Error("initializeWasm() must be awaited first!");
21774 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
21775 return nativeResponseValue;
21777 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
21779 export function AcceptChannel_clone(orig: number): number {
21780 if(!isWasmInitialized) {
21781 throw new Error("initializeWasm() must be awaited first!");
21783 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
21784 return nativeResponseValue;
21786 // void FundingCreated_free(struct LDKFundingCreated this_obj);
21788 export function FundingCreated_free(this_obj: number): void {
21789 if(!isWasmInitialized) {
21790 throw new Error("initializeWasm() must be awaited first!");
21792 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
21793 // debug statements here
21795 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21797 export function FundingCreated_get_temporary_channel_id(this_ptr: number): number {
21798 if(!isWasmInitialized) {
21799 throw new Error("initializeWasm() must be awaited first!");
21801 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
21802 return nativeResponseValue;
21804 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21806 export function FundingCreated_set_temporary_channel_id(this_ptr: number, val: number): void {
21807 if(!isWasmInitialized) {
21808 throw new Error("initializeWasm() must be awaited first!");
21810 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
21811 // debug statements here
21813 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21815 export function FundingCreated_get_funding_txid(this_ptr: number): number {
21816 if(!isWasmInitialized) {
21817 throw new Error("initializeWasm() must be awaited first!");
21819 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
21820 return nativeResponseValue;
21822 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21824 export function FundingCreated_set_funding_txid(this_ptr: number, val: number): void {
21825 if(!isWasmInitialized) {
21826 throw new Error("initializeWasm() must be awaited first!");
21828 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
21829 // debug statements here
21831 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21833 export function FundingCreated_get_funding_output_index(this_ptr: number): number {
21834 if(!isWasmInitialized) {
21835 throw new Error("initializeWasm() must be awaited first!");
21837 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
21838 return nativeResponseValue;
21840 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
21842 export function FundingCreated_set_funding_output_index(this_ptr: number, val: number): void {
21843 if(!isWasmInitialized) {
21844 throw new Error("initializeWasm() must be awaited first!");
21846 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
21847 // debug statements here
21849 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21851 export function FundingCreated_get_signature(this_ptr: number): number {
21852 if(!isWasmInitialized) {
21853 throw new Error("initializeWasm() must be awaited first!");
21855 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
21856 return nativeResponseValue;
21858 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
21860 export function FundingCreated_set_signature(this_ptr: number, val: number): void {
21861 if(!isWasmInitialized) {
21862 throw new Error("initializeWasm() must be awaited first!");
21864 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
21865 // debug statements here
21867 // 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);
21869 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): number {
21870 if(!isWasmInitialized) {
21871 throw new Error("initializeWasm() must be awaited first!");
21873 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
21874 return nativeResponseValue;
21876 // uintptr_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
21878 export function FundingCreated_clone_ptr(arg: number): number {
21879 if(!isWasmInitialized) {
21880 throw new Error("initializeWasm() must be awaited first!");
21882 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
21883 return nativeResponseValue;
21885 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
21887 export function FundingCreated_clone(orig: number): number {
21888 if(!isWasmInitialized) {
21889 throw new Error("initializeWasm() must be awaited first!");
21891 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
21892 return nativeResponseValue;
21894 // void FundingSigned_free(struct LDKFundingSigned this_obj);
21896 export function FundingSigned_free(this_obj: number): void {
21897 if(!isWasmInitialized) {
21898 throw new Error("initializeWasm() must be awaited first!");
21900 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
21901 // debug statements here
21903 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
21905 export function FundingSigned_get_channel_id(this_ptr: number): number {
21906 if(!isWasmInitialized) {
21907 throw new Error("initializeWasm() must be awaited first!");
21909 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
21910 return nativeResponseValue;
21912 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21914 export function FundingSigned_set_channel_id(this_ptr: number, val: number): void {
21915 if(!isWasmInitialized) {
21916 throw new Error("initializeWasm() must be awaited first!");
21918 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
21919 // debug statements here
21921 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
21923 export function FundingSigned_get_signature(this_ptr: number): number {
21924 if(!isWasmInitialized) {
21925 throw new Error("initializeWasm() must be awaited first!");
21927 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
21928 return nativeResponseValue;
21930 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21932 export function FundingSigned_set_signature(this_ptr: number, val: number): void {
21933 if(!isWasmInitialized) {
21934 throw new Error("initializeWasm() must be awaited first!");
21936 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
21937 // debug statements here
21939 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
21941 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): number {
21942 if(!isWasmInitialized) {
21943 throw new Error("initializeWasm() must be awaited first!");
21945 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
21946 return nativeResponseValue;
21948 // uintptr_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
21950 export function FundingSigned_clone_ptr(arg: number): number {
21951 if(!isWasmInitialized) {
21952 throw new Error("initializeWasm() must be awaited first!");
21954 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
21955 return nativeResponseValue;
21957 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
21959 export function FundingSigned_clone(orig: number): number {
21960 if(!isWasmInitialized) {
21961 throw new Error("initializeWasm() must be awaited first!");
21963 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
21964 return nativeResponseValue;
21966 // void ChannelReady_free(struct LDKChannelReady this_obj);
21968 export function ChannelReady_free(this_obj: number): void {
21969 if(!isWasmInitialized) {
21970 throw new Error("initializeWasm() must be awaited first!");
21972 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
21973 // debug statements here
21975 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
21977 export function ChannelReady_get_channel_id(this_ptr: number): number {
21978 if(!isWasmInitialized) {
21979 throw new Error("initializeWasm() must be awaited first!");
21981 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
21982 return nativeResponseValue;
21984 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21986 export function ChannelReady_set_channel_id(this_ptr: number, val: number): void {
21987 if(!isWasmInitialized) {
21988 throw new Error("initializeWasm() must be awaited first!");
21990 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
21991 // debug statements here
21993 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
21995 export function ChannelReady_get_next_per_commitment_point(this_ptr: number): number {
21996 if(!isWasmInitialized) {
21997 throw new Error("initializeWasm() must be awaited first!");
21999 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
22000 return nativeResponseValue;
22002 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22004 export function ChannelReady_set_next_per_commitment_point(this_ptr: number, val: number): void {
22005 if(!isWasmInitialized) {
22006 throw new Error("initializeWasm() must be awaited first!");
22008 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
22009 // debug statements here
22011 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
22013 export function ChannelReady_get_short_channel_id_alias(this_ptr: number): number {
22014 if(!isWasmInitialized) {
22015 throw new Error("initializeWasm() must be awaited first!");
22017 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
22018 return nativeResponseValue;
22020 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
22022 export function ChannelReady_set_short_channel_id_alias(this_ptr: number, val: number): void {
22023 if(!isWasmInitialized) {
22024 throw new Error("initializeWasm() must be awaited first!");
22026 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
22027 // debug statements here
22029 // 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);
22031 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: number): number {
22032 if(!isWasmInitialized) {
22033 throw new Error("initializeWasm() must be awaited first!");
22035 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
22036 return nativeResponseValue;
22038 // uintptr_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
22040 export function ChannelReady_clone_ptr(arg: number): number {
22041 if(!isWasmInitialized) {
22042 throw new Error("initializeWasm() must be awaited first!");
22044 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
22045 return nativeResponseValue;
22047 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
22049 export function ChannelReady_clone(orig: number): number {
22050 if(!isWasmInitialized) {
22051 throw new Error("initializeWasm() must be awaited first!");
22053 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
22054 return nativeResponseValue;
22056 // void Shutdown_free(struct LDKShutdown this_obj);
22058 export function Shutdown_free(this_obj: number): void {
22059 if(!isWasmInitialized) {
22060 throw new Error("initializeWasm() must be awaited first!");
22062 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
22063 // debug statements here
22065 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
22067 export function Shutdown_get_channel_id(this_ptr: number): number {
22068 if(!isWasmInitialized) {
22069 throw new Error("initializeWasm() must be awaited first!");
22071 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
22072 return nativeResponseValue;
22074 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22076 export function Shutdown_set_channel_id(this_ptr: number, val: number): void {
22077 if(!isWasmInitialized) {
22078 throw new Error("initializeWasm() must be awaited first!");
22080 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
22081 // debug statements here
22083 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
22085 export function Shutdown_get_scriptpubkey(this_ptr: number): number {
22086 if(!isWasmInitialized) {
22087 throw new Error("initializeWasm() must be awaited first!");
22089 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
22090 return nativeResponseValue;
22092 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
22094 export function Shutdown_set_scriptpubkey(this_ptr: number, val: number): void {
22095 if(!isWasmInitialized) {
22096 throw new Error("initializeWasm() must be awaited first!");
22098 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
22099 // debug statements here
22101 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
22103 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): number {
22104 if(!isWasmInitialized) {
22105 throw new Error("initializeWasm() must be awaited first!");
22107 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
22108 return nativeResponseValue;
22110 // uintptr_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
22112 export function Shutdown_clone_ptr(arg: number): number {
22113 if(!isWasmInitialized) {
22114 throw new Error("initializeWasm() must be awaited first!");
22116 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
22117 return nativeResponseValue;
22119 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
22121 export function Shutdown_clone(orig: number): number {
22122 if(!isWasmInitialized) {
22123 throw new Error("initializeWasm() must be awaited first!");
22125 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
22126 return nativeResponseValue;
22128 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
22130 export function ClosingSignedFeeRange_free(this_obj: number): void {
22131 if(!isWasmInitialized) {
22132 throw new Error("initializeWasm() must be awaited first!");
22134 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
22135 // debug statements here
22137 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
22139 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: number): bigint {
22140 if(!isWasmInitialized) {
22141 throw new Error("initializeWasm() must be awaited first!");
22143 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
22144 return nativeResponseValue;
22146 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
22148 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: number, val: bigint): void {
22149 if(!isWasmInitialized) {
22150 throw new Error("initializeWasm() must be awaited first!");
22152 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
22153 // debug statements here
22155 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
22157 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: number): bigint {
22158 if(!isWasmInitialized) {
22159 throw new Error("initializeWasm() must be awaited first!");
22161 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
22162 return nativeResponseValue;
22164 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
22166 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: number, val: bigint): void {
22167 if(!isWasmInitialized) {
22168 throw new Error("initializeWasm() must be awaited first!");
22170 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
22171 // debug statements here
22173 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
22175 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): number {
22176 if(!isWasmInitialized) {
22177 throw new Error("initializeWasm() must be awaited first!");
22179 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
22180 return nativeResponseValue;
22182 // uintptr_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
22184 export function ClosingSignedFeeRange_clone_ptr(arg: number): number {
22185 if(!isWasmInitialized) {
22186 throw new Error("initializeWasm() must be awaited first!");
22188 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
22189 return nativeResponseValue;
22191 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
22193 export function ClosingSignedFeeRange_clone(orig: number): number {
22194 if(!isWasmInitialized) {
22195 throw new Error("initializeWasm() must be awaited first!");
22197 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
22198 return nativeResponseValue;
22200 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
22202 export function ClosingSigned_free(this_obj: number): void {
22203 if(!isWasmInitialized) {
22204 throw new Error("initializeWasm() must be awaited first!");
22206 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
22207 // debug statements here
22209 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
22211 export function ClosingSigned_get_channel_id(this_ptr: number): number {
22212 if(!isWasmInitialized) {
22213 throw new Error("initializeWasm() must be awaited first!");
22215 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
22216 return nativeResponseValue;
22218 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22220 export function ClosingSigned_set_channel_id(this_ptr: number, val: number): void {
22221 if(!isWasmInitialized) {
22222 throw new Error("initializeWasm() must be awaited first!");
22224 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
22225 // debug statements here
22227 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
22229 export function ClosingSigned_get_fee_satoshis(this_ptr: number): bigint {
22230 if(!isWasmInitialized) {
22231 throw new Error("initializeWasm() must be awaited first!");
22233 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
22234 return nativeResponseValue;
22236 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
22238 export function ClosingSigned_set_fee_satoshis(this_ptr: number, val: bigint): void {
22239 if(!isWasmInitialized) {
22240 throw new Error("initializeWasm() must be awaited first!");
22242 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
22243 // debug statements here
22245 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
22247 export function ClosingSigned_get_signature(this_ptr: number): number {
22248 if(!isWasmInitialized) {
22249 throw new Error("initializeWasm() must be awaited first!");
22251 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
22252 return nativeResponseValue;
22254 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
22256 export function ClosingSigned_set_signature(this_ptr: number, val: number): void {
22257 if(!isWasmInitialized) {
22258 throw new Error("initializeWasm() must be awaited first!");
22260 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
22261 // debug statements here
22263 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
22265 export function ClosingSigned_get_fee_range(this_ptr: number): number {
22266 if(!isWasmInitialized) {
22267 throw new Error("initializeWasm() must be awaited first!");
22269 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
22270 return nativeResponseValue;
22272 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
22274 export function ClosingSigned_set_fee_range(this_ptr: number, val: number): void {
22275 if(!isWasmInitialized) {
22276 throw new Error("initializeWasm() must be awaited first!");
22278 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
22279 // debug statements here
22281 // 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);
22283 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: number): number {
22284 if(!isWasmInitialized) {
22285 throw new Error("initializeWasm() must be awaited first!");
22287 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
22288 return nativeResponseValue;
22290 // uintptr_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
22292 export function ClosingSigned_clone_ptr(arg: number): number {
22293 if(!isWasmInitialized) {
22294 throw new Error("initializeWasm() must be awaited first!");
22296 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
22297 return nativeResponseValue;
22299 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
22301 export function ClosingSigned_clone(orig: number): number {
22302 if(!isWasmInitialized) {
22303 throw new Error("initializeWasm() must be awaited first!");
22305 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
22306 return nativeResponseValue;
22308 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
22310 export function UpdateAddHTLC_free(this_obj: number): void {
22311 if(!isWasmInitialized) {
22312 throw new Error("initializeWasm() must be awaited first!");
22314 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
22315 // debug statements here
22317 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
22319 export function UpdateAddHTLC_get_channel_id(this_ptr: number): number {
22320 if(!isWasmInitialized) {
22321 throw new Error("initializeWasm() must be awaited first!");
22323 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
22324 return nativeResponseValue;
22326 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22328 export function UpdateAddHTLC_set_channel_id(this_ptr: number, val: number): void {
22329 if(!isWasmInitialized) {
22330 throw new Error("initializeWasm() must be awaited first!");
22332 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
22333 // debug statements here
22335 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
22337 export function UpdateAddHTLC_get_htlc_id(this_ptr: number): bigint {
22338 if(!isWasmInitialized) {
22339 throw new Error("initializeWasm() must be awaited first!");
22341 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
22342 return nativeResponseValue;
22344 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
22346 export function UpdateAddHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22347 if(!isWasmInitialized) {
22348 throw new Error("initializeWasm() must be awaited first!");
22350 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
22351 // debug statements here
22353 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
22355 export function UpdateAddHTLC_get_amount_msat(this_ptr: number): bigint {
22356 if(!isWasmInitialized) {
22357 throw new Error("initializeWasm() must be awaited first!");
22359 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
22360 return nativeResponseValue;
22362 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
22364 export function UpdateAddHTLC_set_amount_msat(this_ptr: number, val: bigint): void {
22365 if(!isWasmInitialized) {
22366 throw new Error("initializeWasm() must be awaited first!");
22368 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
22369 // debug statements here
22371 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
22373 export function UpdateAddHTLC_get_payment_hash(this_ptr: number): number {
22374 if(!isWasmInitialized) {
22375 throw new Error("initializeWasm() must be awaited first!");
22377 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
22378 return nativeResponseValue;
22380 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22382 export function UpdateAddHTLC_set_payment_hash(this_ptr: number, val: number): void {
22383 if(!isWasmInitialized) {
22384 throw new Error("initializeWasm() must be awaited first!");
22386 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
22387 // debug statements here
22389 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
22391 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: number): number {
22392 if(!isWasmInitialized) {
22393 throw new Error("initializeWasm() must be awaited first!");
22395 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
22396 return nativeResponseValue;
22398 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
22400 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: number, val: number): void {
22401 if(!isWasmInitialized) {
22402 throw new Error("initializeWasm() must be awaited first!");
22404 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
22405 // debug statements here
22407 // uintptr_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
22409 export function UpdateAddHTLC_clone_ptr(arg: number): number {
22410 if(!isWasmInitialized) {
22411 throw new Error("initializeWasm() must be awaited first!");
22413 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
22414 return nativeResponseValue;
22416 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
22418 export function UpdateAddHTLC_clone(orig: number): number {
22419 if(!isWasmInitialized) {
22420 throw new Error("initializeWasm() must be awaited first!");
22422 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
22423 return nativeResponseValue;
22425 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
22427 export function UpdateFulfillHTLC_free(this_obj: number): void {
22428 if(!isWasmInitialized) {
22429 throw new Error("initializeWasm() must be awaited first!");
22431 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
22432 // debug statements here
22434 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
22436 export function UpdateFulfillHTLC_get_channel_id(this_ptr: number): number {
22437 if(!isWasmInitialized) {
22438 throw new Error("initializeWasm() must be awaited first!");
22440 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
22441 return nativeResponseValue;
22443 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22445 export function UpdateFulfillHTLC_set_channel_id(this_ptr: number, val: number): void {
22446 if(!isWasmInitialized) {
22447 throw new Error("initializeWasm() must be awaited first!");
22449 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
22450 // debug statements here
22452 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
22454 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: number): bigint {
22455 if(!isWasmInitialized) {
22456 throw new Error("initializeWasm() must be awaited first!");
22458 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
22459 return nativeResponseValue;
22461 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
22463 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22464 if(!isWasmInitialized) {
22465 throw new Error("initializeWasm() must be awaited first!");
22467 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
22468 // debug statements here
22470 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
22472 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: number): number {
22473 if(!isWasmInitialized) {
22474 throw new Error("initializeWasm() must be awaited first!");
22476 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
22477 return nativeResponseValue;
22479 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22481 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: number, val: number): void {
22482 if(!isWasmInitialized) {
22483 throw new Error("initializeWasm() must be awaited first!");
22485 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
22486 // debug statements here
22488 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
22490 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): number {
22491 if(!isWasmInitialized) {
22492 throw new Error("initializeWasm() must be awaited first!");
22494 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
22495 return nativeResponseValue;
22497 // uintptr_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
22499 export function UpdateFulfillHTLC_clone_ptr(arg: number): number {
22500 if(!isWasmInitialized) {
22501 throw new Error("initializeWasm() must be awaited first!");
22503 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
22504 return nativeResponseValue;
22506 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
22508 export function UpdateFulfillHTLC_clone(orig: number): number {
22509 if(!isWasmInitialized) {
22510 throw new Error("initializeWasm() must be awaited first!");
22512 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
22513 return nativeResponseValue;
22515 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
22517 export function UpdateFailHTLC_free(this_obj: number): void {
22518 if(!isWasmInitialized) {
22519 throw new Error("initializeWasm() must be awaited first!");
22521 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
22522 // debug statements here
22524 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
22526 export function UpdateFailHTLC_get_channel_id(this_ptr: number): number {
22527 if(!isWasmInitialized) {
22528 throw new Error("initializeWasm() must be awaited first!");
22530 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
22531 return nativeResponseValue;
22533 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22535 export function UpdateFailHTLC_set_channel_id(this_ptr: number, val: number): void {
22536 if(!isWasmInitialized) {
22537 throw new Error("initializeWasm() must be awaited first!");
22539 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
22540 // debug statements here
22542 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
22544 export function UpdateFailHTLC_get_htlc_id(this_ptr: number): bigint {
22545 if(!isWasmInitialized) {
22546 throw new Error("initializeWasm() must be awaited first!");
22548 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
22549 return nativeResponseValue;
22551 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
22553 export function UpdateFailHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22554 if(!isWasmInitialized) {
22555 throw new Error("initializeWasm() must be awaited first!");
22557 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
22558 // debug statements here
22560 // uintptr_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
22562 export function UpdateFailHTLC_clone_ptr(arg: number): number {
22563 if(!isWasmInitialized) {
22564 throw new Error("initializeWasm() must be awaited first!");
22566 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
22567 return nativeResponseValue;
22569 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
22571 export function UpdateFailHTLC_clone(orig: number): number {
22572 if(!isWasmInitialized) {
22573 throw new Error("initializeWasm() must be awaited first!");
22575 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
22576 return nativeResponseValue;
22578 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
22580 export function UpdateFailMalformedHTLC_free(this_obj: number): void {
22581 if(!isWasmInitialized) {
22582 throw new Error("initializeWasm() must be awaited first!");
22584 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
22585 // debug statements here
22587 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
22589 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: number): number {
22590 if(!isWasmInitialized) {
22591 throw new Error("initializeWasm() must be awaited first!");
22593 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
22594 return nativeResponseValue;
22596 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22598 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: number, val: number): void {
22599 if(!isWasmInitialized) {
22600 throw new Error("initializeWasm() must be awaited first!");
22602 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
22603 // debug statements here
22605 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
22607 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: number): bigint {
22608 if(!isWasmInitialized) {
22609 throw new Error("initializeWasm() must be awaited first!");
22611 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
22612 return nativeResponseValue;
22614 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
22616 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22617 if(!isWasmInitialized) {
22618 throw new Error("initializeWasm() must be awaited first!");
22620 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
22621 // debug statements here
22623 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
22625 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: number): number {
22626 if(!isWasmInitialized) {
22627 throw new Error("initializeWasm() must be awaited first!");
22629 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
22630 return nativeResponseValue;
22632 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
22634 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: number, val: number): void {
22635 if(!isWasmInitialized) {
22636 throw new Error("initializeWasm() must be awaited first!");
22638 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
22639 // debug statements here
22641 // uintptr_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
22643 export function UpdateFailMalformedHTLC_clone_ptr(arg: number): number {
22644 if(!isWasmInitialized) {
22645 throw new Error("initializeWasm() must be awaited first!");
22647 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
22648 return nativeResponseValue;
22650 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
22652 export function UpdateFailMalformedHTLC_clone(orig: number): number {
22653 if(!isWasmInitialized) {
22654 throw new Error("initializeWasm() must be awaited first!");
22656 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
22657 return nativeResponseValue;
22659 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
22661 export function CommitmentSigned_free(this_obj: number): void {
22662 if(!isWasmInitialized) {
22663 throw new Error("initializeWasm() must be awaited first!");
22665 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
22666 // debug statements here
22668 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
22670 export function CommitmentSigned_get_channel_id(this_ptr: number): number {
22671 if(!isWasmInitialized) {
22672 throw new Error("initializeWasm() must be awaited first!");
22674 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
22675 return nativeResponseValue;
22677 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22679 export function CommitmentSigned_set_channel_id(this_ptr: number, val: number): void {
22680 if(!isWasmInitialized) {
22681 throw new Error("initializeWasm() must be awaited first!");
22683 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
22684 // debug statements here
22686 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
22688 export function CommitmentSigned_get_signature(this_ptr: number): number {
22689 if(!isWasmInitialized) {
22690 throw new Error("initializeWasm() must be awaited first!");
22692 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
22693 return nativeResponseValue;
22695 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
22697 export function CommitmentSigned_set_signature(this_ptr: number, val: number): void {
22698 if(!isWasmInitialized) {
22699 throw new Error("initializeWasm() must be awaited first!");
22701 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
22702 // debug statements here
22704 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
22706 export function CommitmentSigned_set_htlc_signatures(this_ptr: number, val: number): void {
22707 if(!isWasmInitialized) {
22708 throw new Error("initializeWasm() must be awaited first!");
22710 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
22711 // debug statements here
22713 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
22715 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): number {
22716 if(!isWasmInitialized) {
22717 throw new Error("initializeWasm() must be awaited first!");
22719 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
22720 return nativeResponseValue;
22722 // uintptr_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
22724 export function CommitmentSigned_clone_ptr(arg: number): number {
22725 if(!isWasmInitialized) {
22726 throw new Error("initializeWasm() must be awaited first!");
22728 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
22729 return nativeResponseValue;
22731 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
22733 export function CommitmentSigned_clone(orig: number): number {
22734 if(!isWasmInitialized) {
22735 throw new Error("initializeWasm() must be awaited first!");
22737 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
22738 return nativeResponseValue;
22740 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
22742 export function RevokeAndACK_free(this_obj: number): void {
22743 if(!isWasmInitialized) {
22744 throw new Error("initializeWasm() must be awaited first!");
22746 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
22747 // debug statements here
22749 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22751 export function RevokeAndACK_get_channel_id(this_ptr: number): number {
22752 if(!isWasmInitialized) {
22753 throw new Error("initializeWasm() must be awaited first!");
22755 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
22756 return nativeResponseValue;
22758 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22760 export function RevokeAndACK_set_channel_id(this_ptr: number, val: number): void {
22761 if(!isWasmInitialized) {
22762 throw new Error("initializeWasm() must be awaited first!");
22764 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
22765 // debug statements here
22767 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22769 export function RevokeAndACK_get_per_commitment_secret(this_ptr: number): number {
22770 if(!isWasmInitialized) {
22771 throw new Error("initializeWasm() must be awaited first!");
22773 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
22774 return nativeResponseValue;
22776 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22778 export function RevokeAndACK_set_per_commitment_secret(this_ptr: number, val: number): void {
22779 if(!isWasmInitialized) {
22780 throw new Error("initializeWasm() must be awaited first!");
22782 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
22783 // debug statements here
22785 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
22787 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: number): number {
22788 if(!isWasmInitialized) {
22789 throw new Error("initializeWasm() must be awaited first!");
22791 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
22792 return nativeResponseValue;
22794 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22796 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: number, val: number): void {
22797 if(!isWasmInitialized) {
22798 throw new Error("initializeWasm() must be awaited first!");
22800 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
22801 // debug statements here
22803 // 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);
22805 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): number {
22806 if(!isWasmInitialized) {
22807 throw new Error("initializeWasm() must be awaited first!");
22809 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
22810 return nativeResponseValue;
22812 // uintptr_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
22814 export function RevokeAndACK_clone_ptr(arg: number): number {
22815 if(!isWasmInitialized) {
22816 throw new Error("initializeWasm() must be awaited first!");
22818 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
22819 return nativeResponseValue;
22821 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
22823 export function RevokeAndACK_clone(orig: number): number {
22824 if(!isWasmInitialized) {
22825 throw new Error("initializeWasm() must be awaited first!");
22827 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
22828 return nativeResponseValue;
22830 // void UpdateFee_free(struct LDKUpdateFee this_obj);
22832 export function UpdateFee_free(this_obj: number): void {
22833 if(!isWasmInitialized) {
22834 throw new Error("initializeWasm() must be awaited first!");
22836 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
22837 // debug statements here
22839 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
22841 export function UpdateFee_get_channel_id(this_ptr: number): number {
22842 if(!isWasmInitialized) {
22843 throw new Error("initializeWasm() must be awaited first!");
22845 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
22846 return nativeResponseValue;
22848 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22850 export function UpdateFee_set_channel_id(this_ptr: number, val: number): void {
22851 if(!isWasmInitialized) {
22852 throw new Error("initializeWasm() must be awaited first!");
22854 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
22855 // debug statements here
22857 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
22859 export function UpdateFee_get_feerate_per_kw(this_ptr: number): number {
22860 if(!isWasmInitialized) {
22861 throw new Error("initializeWasm() must be awaited first!");
22863 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
22864 return nativeResponseValue;
22866 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
22868 export function UpdateFee_set_feerate_per_kw(this_ptr: number, val: number): void {
22869 if(!isWasmInitialized) {
22870 throw new Error("initializeWasm() must be awaited first!");
22872 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
22873 // debug statements here
22875 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
22877 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): number {
22878 if(!isWasmInitialized) {
22879 throw new Error("initializeWasm() must be awaited first!");
22881 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
22882 return nativeResponseValue;
22884 // uintptr_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
22886 export function UpdateFee_clone_ptr(arg: number): number {
22887 if(!isWasmInitialized) {
22888 throw new Error("initializeWasm() must be awaited first!");
22890 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
22891 return nativeResponseValue;
22893 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
22895 export function UpdateFee_clone(orig: number): number {
22896 if(!isWasmInitialized) {
22897 throw new Error("initializeWasm() must be awaited first!");
22899 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
22900 return nativeResponseValue;
22902 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
22904 export function DataLossProtect_free(this_obj: number): void {
22905 if(!isWasmInitialized) {
22906 throw new Error("initializeWasm() must be awaited first!");
22908 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
22909 // debug statements here
22911 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
22913 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: number): number {
22914 if(!isWasmInitialized) {
22915 throw new Error("initializeWasm() must be awaited first!");
22917 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
22918 return nativeResponseValue;
22920 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22922 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: number, val: number): void {
22923 if(!isWasmInitialized) {
22924 throw new Error("initializeWasm() must be awaited first!");
22926 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
22927 // debug statements here
22929 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
22931 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: number): number {
22932 if(!isWasmInitialized) {
22933 throw new Error("initializeWasm() must be awaited first!");
22935 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
22936 return nativeResponseValue;
22938 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22940 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: number, val: number): void {
22941 if(!isWasmInitialized) {
22942 throw new Error("initializeWasm() must be awaited first!");
22944 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
22945 // debug statements here
22947 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
22949 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): number {
22950 if(!isWasmInitialized) {
22951 throw new Error("initializeWasm() must be awaited first!");
22953 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
22954 return nativeResponseValue;
22956 // uintptr_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
22958 export function DataLossProtect_clone_ptr(arg: number): number {
22959 if(!isWasmInitialized) {
22960 throw new Error("initializeWasm() must be awaited first!");
22962 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
22963 return nativeResponseValue;
22965 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
22967 export function DataLossProtect_clone(orig: number): number {
22968 if(!isWasmInitialized) {
22969 throw new Error("initializeWasm() must be awaited first!");
22971 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
22972 return nativeResponseValue;
22974 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
22976 export function ChannelReestablish_free(this_obj: number): void {
22977 if(!isWasmInitialized) {
22978 throw new Error("initializeWasm() must be awaited first!");
22980 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
22981 // debug statements here
22983 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
22985 export function ChannelReestablish_get_channel_id(this_ptr: number): number {
22986 if(!isWasmInitialized) {
22987 throw new Error("initializeWasm() must be awaited first!");
22989 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
22990 return nativeResponseValue;
22992 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22994 export function ChannelReestablish_set_channel_id(this_ptr: number, val: number): void {
22995 if(!isWasmInitialized) {
22996 throw new Error("initializeWasm() must be awaited first!");
22998 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
22999 // debug statements here
23001 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
23003 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: number): bigint {
23004 if(!isWasmInitialized) {
23005 throw new Error("initializeWasm() must be awaited first!");
23007 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
23008 return nativeResponseValue;
23010 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
23012 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: number, val: bigint): void {
23013 if(!isWasmInitialized) {
23014 throw new Error("initializeWasm() must be awaited first!");
23016 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
23017 // debug statements here
23019 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
23021 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: number): bigint {
23022 if(!isWasmInitialized) {
23023 throw new Error("initializeWasm() must be awaited first!");
23025 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
23026 return nativeResponseValue;
23028 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
23030 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: number, val: bigint): void {
23031 if(!isWasmInitialized) {
23032 throw new Error("initializeWasm() must be awaited first!");
23034 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
23035 // debug statements here
23037 // uintptr_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
23039 export function ChannelReestablish_clone_ptr(arg: number): number {
23040 if(!isWasmInitialized) {
23041 throw new Error("initializeWasm() must be awaited first!");
23043 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
23044 return nativeResponseValue;
23046 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
23048 export function ChannelReestablish_clone(orig: number): number {
23049 if(!isWasmInitialized) {
23050 throw new Error("initializeWasm() must be awaited first!");
23052 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
23053 return nativeResponseValue;
23055 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
23057 export function AnnouncementSignatures_free(this_obj: number): void {
23058 if(!isWasmInitialized) {
23059 throw new Error("initializeWasm() must be awaited first!");
23061 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
23062 // debug statements here
23064 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
23066 export function AnnouncementSignatures_get_channel_id(this_ptr: number): number {
23067 if(!isWasmInitialized) {
23068 throw new Error("initializeWasm() must be awaited first!");
23070 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
23071 return nativeResponseValue;
23073 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23075 export function AnnouncementSignatures_set_channel_id(this_ptr: number, val: number): void {
23076 if(!isWasmInitialized) {
23077 throw new Error("initializeWasm() must be awaited first!");
23079 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
23080 // debug statements here
23082 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
23084 export function AnnouncementSignatures_get_short_channel_id(this_ptr: number): bigint {
23085 if(!isWasmInitialized) {
23086 throw new Error("initializeWasm() must be awaited first!");
23088 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
23089 return nativeResponseValue;
23091 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
23093 export function AnnouncementSignatures_set_short_channel_id(this_ptr: number, val: bigint): void {
23094 if(!isWasmInitialized) {
23095 throw new Error("initializeWasm() must be awaited first!");
23097 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
23098 // debug statements here
23100 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
23102 export function AnnouncementSignatures_get_node_signature(this_ptr: number): number {
23103 if(!isWasmInitialized) {
23104 throw new Error("initializeWasm() must be awaited first!");
23106 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
23107 return nativeResponseValue;
23109 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
23111 export function AnnouncementSignatures_set_node_signature(this_ptr: number, val: number): void {
23112 if(!isWasmInitialized) {
23113 throw new Error("initializeWasm() must be awaited first!");
23115 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
23116 // debug statements here
23118 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
23120 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: number): number {
23121 if(!isWasmInitialized) {
23122 throw new Error("initializeWasm() must be awaited first!");
23124 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
23125 return nativeResponseValue;
23127 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
23129 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: number, val: number): void {
23130 if(!isWasmInitialized) {
23131 throw new Error("initializeWasm() must be awaited first!");
23133 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
23134 // debug statements here
23136 // 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);
23138 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): number {
23139 if(!isWasmInitialized) {
23140 throw new Error("initializeWasm() must be awaited first!");
23142 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
23143 return nativeResponseValue;
23145 // uintptr_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
23147 export function AnnouncementSignatures_clone_ptr(arg: number): number {
23148 if(!isWasmInitialized) {
23149 throw new Error("initializeWasm() must be awaited first!");
23151 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
23152 return nativeResponseValue;
23154 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
23156 export function AnnouncementSignatures_clone(orig: number): number {
23157 if(!isWasmInitialized) {
23158 throw new Error("initializeWasm() must be awaited first!");
23160 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
23161 return nativeResponseValue;
23163 // void NetAddress_free(struct LDKNetAddress this_ptr);
23165 export function NetAddress_free(this_ptr: number): void {
23166 if(!isWasmInitialized) {
23167 throw new Error("initializeWasm() must be awaited first!");
23169 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
23170 // debug statements here
23172 // uintptr_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
23174 export function NetAddress_clone_ptr(arg: number): number {
23175 if(!isWasmInitialized) {
23176 throw new Error("initializeWasm() must be awaited first!");
23178 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
23179 return nativeResponseValue;
23181 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
23183 export function NetAddress_clone(orig: number): number {
23184 if(!isWasmInitialized) {
23185 throw new Error("initializeWasm() must be awaited first!");
23187 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
23188 return nativeResponseValue;
23190 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
23192 export function NetAddress_ipv4(addr: number, port: number): number {
23193 if(!isWasmInitialized) {
23194 throw new Error("initializeWasm() must be awaited first!");
23196 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
23197 return nativeResponseValue;
23199 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
23201 export function NetAddress_ipv6(addr: number, port: number): number {
23202 if(!isWasmInitialized) {
23203 throw new Error("initializeWasm() must be awaited first!");
23205 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
23206 return nativeResponseValue;
23208 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
23210 export function NetAddress_onion_v2(a: number): number {
23211 if(!isWasmInitialized) {
23212 throw new Error("initializeWasm() must be awaited first!");
23214 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
23215 return nativeResponseValue;
23217 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
23219 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): number {
23220 if(!isWasmInitialized) {
23221 throw new Error("initializeWasm() must be awaited first!");
23223 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
23224 return nativeResponseValue;
23226 // struct LDKNetAddress NetAddress_hostname(struct LDKHostname hostname, uint16_t port);
23228 export function NetAddress_hostname(hostname: number, port: number): number {
23229 if(!isWasmInitialized) {
23230 throw new Error("initializeWasm() must be awaited first!");
23232 const nativeResponseValue = wasm.TS_NetAddress_hostname(hostname, port);
23233 return nativeResponseValue;
23235 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
23237 export function NetAddress_write(obj: number): number {
23238 if(!isWasmInitialized) {
23239 throw new Error("initializeWasm() must be awaited first!");
23241 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
23242 return nativeResponseValue;
23244 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
23246 export function NetAddress_read(ser: number): number {
23247 if(!isWasmInitialized) {
23248 throw new Error("initializeWasm() must be awaited first!");
23250 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
23251 return nativeResponseValue;
23253 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
23255 export function UnsignedNodeAnnouncement_free(this_obj: number): void {
23256 if(!isWasmInitialized) {
23257 throw new Error("initializeWasm() must be awaited first!");
23259 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
23260 // debug statements here
23262 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
23264 export function UnsignedNodeAnnouncement_get_features(this_ptr: number): number {
23265 if(!isWasmInitialized) {
23266 throw new Error("initializeWasm() must be awaited first!");
23268 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
23269 return nativeResponseValue;
23271 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
23273 export function UnsignedNodeAnnouncement_set_features(this_ptr: number, val: number): void {
23274 if(!isWasmInitialized) {
23275 throw new Error("initializeWasm() must be awaited first!");
23277 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
23278 // debug statements here
23280 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
23282 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: number): number {
23283 if(!isWasmInitialized) {
23284 throw new Error("initializeWasm() must be awaited first!");
23286 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
23287 return nativeResponseValue;
23289 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
23291 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: number, val: number): void {
23292 if(!isWasmInitialized) {
23293 throw new Error("initializeWasm() must be awaited first!");
23295 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
23296 // debug statements here
23298 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
23300 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: number): number {
23301 if(!isWasmInitialized) {
23302 throw new Error("initializeWasm() must be awaited first!");
23304 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
23305 return nativeResponseValue;
23307 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23309 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: number, val: number): void {
23310 if(!isWasmInitialized) {
23311 throw new Error("initializeWasm() must be awaited first!");
23313 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
23314 // debug statements here
23316 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
23318 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: number): number {
23319 if(!isWasmInitialized) {
23320 throw new Error("initializeWasm() must be awaited first!");
23322 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
23323 return nativeResponseValue;
23325 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
23327 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: number, val: number): void {
23328 if(!isWasmInitialized) {
23329 throw new Error("initializeWasm() must be awaited first!");
23331 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
23332 // debug statements here
23334 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
23336 export function UnsignedNodeAnnouncement_get_alias(this_ptr: number): number {
23337 if(!isWasmInitialized) {
23338 throw new Error("initializeWasm() must be awaited first!");
23340 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
23341 return nativeResponseValue;
23343 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23345 export function UnsignedNodeAnnouncement_set_alias(this_ptr: number, val: number): void {
23346 if(!isWasmInitialized) {
23347 throw new Error("initializeWasm() must be awaited first!");
23349 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
23350 // debug statements here
23352 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
23354 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: number, val: number): void {
23355 if(!isWasmInitialized) {
23356 throw new Error("initializeWasm() must be awaited first!");
23358 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
23359 // debug statements here
23361 // uintptr_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
23363 export function UnsignedNodeAnnouncement_clone_ptr(arg: number): number {
23364 if(!isWasmInitialized) {
23365 throw new Error("initializeWasm() must be awaited first!");
23367 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
23368 return nativeResponseValue;
23370 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
23372 export function UnsignedNodeAnnouncement_clone(orig: number): number {
23373 if(!isWasmInitialized) {
23374 throw new Error("initializeWasm() must be awaited first!");
23376 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
23377 return nativeResponseValue;
23379 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
23381 export function NodeAnnouncement_free(this_obj: number): void {
23382 if(!isWasmInitialized) {
23383 throw new Error("initializeWasm() must be awaited first!");
23385 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
23386 // debug statements here
23388 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
23390 export function NodeAnnouncement_get_signature(this_ptr: number): number {
23391 if(!isWasmInitialized) {
23392 throw new Error("initializeWasm() must be awaited first!");
23394 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
23395 return nativeResponseValue;
23397 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23399 export function NodeAnnouncement_set_signature(this_ptr: number, val: number): void {
23400 if(!isWasmInitialized) {
23401 throw new Error("initializeWasm() must be awaited first!");
23403 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
23404 // debug statements here
23406 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
23408 export function NodeAnnouncement_get_contents(this_ptr: number): number {
23409 if(!isWasmInitialized) {
23410 throw new Error("initializeWasm() must be awaited first!");
23412 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
23413 return nativeResponseValue;
23415 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
23417 export function NodeAnnouncement_set_contents(this_ptr: number, val: number): void {
23418 if(!isWasmInitialized) {
23419 throw new Error("initializeWasm() must be awaited first!");
23421 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
23422 // debug statements here
23424 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
23426 export function NodeAnnouncement_new(signature_arg: number, contents_arg: number): number {
23427 if(!isWasmInitialized) {
23428 throw new Error("initializeWasm() must be awaited first!");
23430 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
23431 return nativeResponseValue;
23433 // uintptr_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
23435 export function NodeAnnouncement_clone_ptr(arg: number): number {
23436 if(!isWasmInitialized) {
23437 throw new Error("initializeWasm() must be awaited first!");
23439 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
23440 return nativeResponseValue;
23442 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
23444 export function NodeAnnouncement_clone(orig: number): number {
23445 if(!isWasmInitialized) {
23446 throw new Error("initializeWasm() must be awaited first!");
23448 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
23449 return nativeResponseValue;
23451 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
23453 export function UnsignedChannelAnnouncement_free(this_obj: number): void {
23454 if(!isWasmInitialized) {
23455 throw new Error("initializeWasm() must be awaited first!");
23457 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
23458 // debug statements here
23460 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23462 export function UnsignedChannelAnnouncement_get_features(this_ptr: number): number {
23463 if(!isWasmInitialized) {
23464 throw new Error("initializeWasm() must be awaited first!");
23466 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
23467 return nativeResponseValue;
23469 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
23471 export function UnsignedChannelAnnouncement_set_features(this_ptr: number, val: number): void {
23472 if(!isWasmInitialized) {
23473 throw new Error("initializeWasm() must be awaited first!");
23475 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
23476 // debug statements here
23478 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
23480 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: number): number {
23481 if(!isWasmInitialized) {
23482 throw new Error("initializeWasm() must be awaited first!");
23484 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
23485 return nativeResponseValue;
23487 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23489 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: number, val: number): void {
23490 if(!isWasmInitialized) {
23491 throw new Error("initializeWasm() must be awaited first!");
23493 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
23494 // debug statements here
23496 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23498 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: number): bigint {
23499 if(!isWasmInitialized) {
23500 throw new Error("initializeWasm() must be awaited first!");
23502 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
23503 return nativeResponseValue;
23505 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
23507 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: number, val: bigint): void {
23508 if(!isWasmInitialized) {
23509 throw new Error("initializeWasm() must be awaited first!");
23511 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
23512 // debug statements here
23514 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23516 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: number): number {
23517 if(!isWasmInitialized) {
23518 throw new Error("initializeWasm() must be awaited first!");
23520 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
23521 return nativeResponseValue;
23523 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23525 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: number, val: number): void {
23526 if(!isWasmInitialized) {
23527 throw new Error("initializeWasm() must be awaited first!");
23529 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
23530 // debug statements here
23532 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23534 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: number): number {
23535 if(!isWasmInitialized) {
23536 throw new Error("initializeWasm() must be awaited first!");
23538 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
23539 return nativeResponseValue;
23541 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23543 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: number, val: number): void {
23544 if(!isWasmInitialized) {
23545 throw new Error("initializeWasm() must be awaited first!");
23547 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
23548 // debug statements here
23550 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23552 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: number): number {
23553 if(!isWasmInitialized) {
23554 throw new Error("initializeWasm() must be awaited first!");
23556 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
23557 return nativeResponseValue;
23559 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23561 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: number, val: number): void {
23562 if(!isWasmInitialized) {
23563 throw new Error("initializeWasm() must be awaited first!");
23565 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
23566 // debug statements here
23568 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23570 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: number): number {
23571 if(!isWasmInitialized) {
23572 throw new Error("initializeWasm() must be awaited first!");
23574 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
23575 return nativeResponseValue;
23577 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23579 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: number, val: number): void {
23580 if(!isWasmInitialized) {
23581 throw new Error("initializeWasm() must be awaited first!");
23583 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
23584 // debug statements here
23586 // uintptr_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
23588 export function UnsignedChannelAnnouncement_clone_ptr(arg: number): number {
23589 if(!isWasmInitialized) {
23590 throw new Error("initializeWasm() must be awaited first!");
23592 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
23593 return nativeResponseValue;
23595 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
23597 export function UnsignedChannelAnnouncement_clone(orig: number): number {
23598 if(!isWasmInitialized) {
23599 throw new Error("initializeWasm() must be awaited first!");
23601 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
23602 return nativeResponseValue;
23604 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
23606 export function ChannelAnnouncement_free(this_obj: number): void {
23607 if(!isWasmInitialized) {
23608 throw new Error("initializeWasm() must be awaited first!");
23610 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
23611 // debug statements here
23613 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23615 export function ChannelAnnouncement_get_node_signature_1(this_ptr: number): number {
23616 if(!isWasmInitialized) {
23617 throw new Error("initializeWasm() must be awaited first!");
23619 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
23620 return nativeResponseValue;
23622 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23624 export function ChannelAnnouncement_set_node_signature_1(this_ptr: number, val: number): void {
23625 if(!isWasmInitialized) {
23626 throw new Error("initializeWasm() must be awaited first!");
23628 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
23629 // debug statements here
23631 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23633 export function ChannelAnnouncement_get_node_signature_2(this_ptr: number): number {
23634 if(!isWasmInitialized) {
23635 throw new Error("initializeWasm() must be awaited first!");
23637 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
23638 return nativeResponseValue;
23640 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23642 export function ChannelAnnouncement_set_node_signature_2(this_ptr: number, val: number): void {
23643 if(!isWasmInitialized) {
23644 throw new Error("initializeWasm() must be awaited first!");
23646 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
23647 // debug statements here
23649 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23651 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: number): number {
23652 if(!isWasmInitialized) {
23653 throw new Error("initializeWasm() must be awaited first!");
23655 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
23656 return nativeResponseValue;
23658 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23660 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: number, val: number): void {
23661 if(!isWasmInitialized) {
23662 throw new Error("initializeWasm() must be awaited first!");
23664 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
23665 // debug statements here
23667 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23669 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: number): number {
23670 if(!isWasmInitialized) {
23671 throw new Error("initializeWasm() must be awaited first!");
23673 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
23674 return nativeResponseValue;
23676 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23678 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: number, val: number): void {
23679 if(!isWasmInitialized) {
23680 throw new Error("initializeWasm() must be awaited first!");
23682 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
23683 // debug statements here
23685 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23687 export function ChannelAnnouncement_get_contents(this_ptr: number): number {
23688 if(!isWasmInitialized) {
23689 throw new Error("initializeWasm() must be awaited first!");
23691 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
23692 return nativeResponseValue;
23694 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
23696 export function ChannelAnnouncement_set_contents(this_ptr: number, val: number): void {
23697 if(!isWasmInitialized) {
23698 throw new Error("initializeWasm() must be awaited first!");
23700 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
23701 // debug statements here
23703 // 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);
23705 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 {
23706 if(!isWasmInitialized) {
23707 throw new Error("initializeWasm() must be awaited first!");
23709 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
23710 return nativeResponseValue;
23712 // uintptr_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
23714 export function ChannelAnnouncement_clone_ptr(arg: number): number {
23715 if(!isWasmInitialized) {
23716 throw new Error("initializeWasm() must be awaited first!");
23718 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
23719 return nativeResponseValue;
23721 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
23723 export function ChannelAnnouncement_clone(orig: number): number {
23724 if(!isWasmInitialized) {
23725 throw new Error("initializeWasm() must be awaited first!");
23727 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
23728 return nativeResponseValue;
23730 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
23732 export function UnsignedChannelUpdate_free(this_obj: number): void {
23733 if(!isWasmInitialized) {
23734 throw new Error("initializeWasm() must be awaited first!");
23736 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
23737 // debug statements here
23739 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
23741 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: number): number {
23742 if(!isWasmInitialized) {
23743 throw new Error("initializeWasm() must be awaited first!");
23745 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
23746 return nativeResponseValue;
23748 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23750 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: number, val: number): void {
23751 if(!isWasmInitialized) {
23752 throw new Error("initializeWasm() must be awaited first!");
23754 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
23755 // debug statements here
23757 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23759 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: number): bigint {
23760 if(!isWasmInitialized) {
23761 throw new Error("initializeWasm() must be awaited first!");
23763 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
23764 return nativeResponseValue;
23766 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23768 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: number, val: bigint): void {
23769 if(!isWasmInitialized) {
23770 throw new Error("initializeWasm() must be awaited first!");
23772 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
23773 // debug statements here
23775 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23777 export function UnsignedChannelUpdate_get_timestamp(this_ptr: number): number {
23778 if(!isWasmInitialized) {
23779 throw new Error("initializeWasm() must be awaited first!");
23781 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
23782 return nativeResponseValue;
23784 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23786 export function UnsignedChannelUpdate_set_timestamp(this_ptr: number, val: number): void {
23787 if(!isWasmInitialized) {
23788 throw new Error("initializeWasm() must be awaited first!");
23790 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
23791 // debug statements here
23793 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23795 export function UnsignedChannelUpdate_get_flags(this_ptr: number): number {
23796 if(!isWasmInitialized) {
23797 throw new Error("initializeWasm() must be awaited first!");
23799 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
23800 return nativeResponseValue;
23802 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
23804 export function UnsignedChannelUpdate_set_flags(this_ptr: number, val: number): void {
23805 if(!isWasmInitialized) {
23806 throw new Error("initializeWasm() must be awaited first!");
23808 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
23809 // debug statements here
23811 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23813 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: number): number {
23814 if(!isWasmInitialized) {
23815 throw new Error("initializeWasm() must be awaited first!");
23817 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
23818 return nativeResponseValue;
23820 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
23822 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: number, val: number): void {
23823 if(!isWasmInitialized) {
23824 throw new Error("initializeWasm() must be awaited first!");
23826 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
23827 // debug statements here
23829 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23831 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: number): bigint {
23832 if(!isWasmInitialized) {
23833 throw new Error("initializeWasm() must be awaited first!");
23835 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
23836 return nativeResponseValue;
23838 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23840 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
23841 if(!isWasmInitialized) {
23842 throw new Error("initializeWasm() must be awaited first!");
23844 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
23845 // debug statements here
23847 // uint64_t UnsignedChannelUpdate_get_htlc_maximum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23849 export function UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr: number): bigint {
23850 if(!isWasmInitialized) {
23851 throw new Error("initializeWasm() must be awaited first!");
23853 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_maximum_msat(this_ptr);
23854 return nativeResponseValue;
23856 // void UnsignedChannelUpdate_set_htlc_maximum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23858 export function UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr: number, val: bigint): void {
23859 if(!isWasmInitialized) {
23860 throw new Error("initializeWasm() must be awaited first!");
23862 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_maximum_msat(this_ptr, val);
23863 // debug statements here
23865 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23867 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: number): number {
23868 if(!isWasmInitialized) {
23869 throw new Error("initializeWasm() must be awaited first!");
23871 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
23872 return nativeResponseValue;
23874 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23876 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: number, val: number): void {
23877 if(!isWasmInitialized) {
23878 throw new Error("initializeWasm() must be awaited first!");
23880 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
23881 // debug statements here
23883 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23885 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: number): number {
23886 if(!isWasmInitialized) {
23887 throw new Error("initializeWasm() must be awaited first!");
23889 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
23890 return nativeResponseValue;
23892 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23894 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: number, val: number): void {
23895 if(!isWasmInitialized) {
23896 throw new Error("initializeWasm() must be awaited first!");
23898 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
23899 // debug statements here
23901 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
23903 export function UnsignedChannelUpdate_set_excess_data(this_ptr: number, val: number): void {
23904 if(!isWasmInitialized) {
23905 throw new Error("initializeWasm() must be awaited first!");
23907 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
23908 // debug statements here
23910 // MUST_USE_RES struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_new(struct LDKThirtyTwoBytes chain_hash_arg, uint64_t short_channel_id_arg, uint32_t timestamp_arg, uint8_t flags_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, uint64_t htlc_maximum_msat_arg, uint32_t fee_base_msat_arg, uint32_t fee_proportional_millionths_arg, struct LDKCVec_u8Z excess_data_arg);
23912 export function UnsignedChannelUpdate_new(chain_hash_arg: number, short_channel_id_arg: bigint, timestamp_arg: number, flags_arg: number, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint, fee_base_msat_arg: number, fee_proportional_millionths_arg: number, excess_data_arg: number): number {
23913 if(!isWasmInitialized) {
23914 throw new Error("initializeWasm() must be awaited first!");
23916 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_new(chain_hash_arg, short_channel_id_arg, timestamp_arg, flags_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, fee_base_msat_arg, fee_proportional_millionths_arg, excess_data_arg);
23917 return nativeResponseValue;
23919 // uintptr_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
23921 export function UnsignedChannelUpdate_clone_ptr(arg: number): number {
23922 if(!isWasmInitialized) {
23923 throw new Error("initializeWasm() must be awaited first!");
23925 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
23926 return nativeResponseValue;
23928 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
23930 export function UnsignedChannelUpdate_clone(orig: number): number {
23931 if(!isWasmInitialized) {
23932 throw new Error("initializeWasm() must be awaited first!");
23934 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
23935 return nativeResponseValue;
23937 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
23939 export function ChannelUpdate_free(this_obj: number): void {
23940 if(!isWasmInitialized) {
23941 throw new Error("initializeWasm() must be awaited first!");
23943 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
23944 // debug statements here
23946 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
23948 export function ChannelUpdate_get_signature(this_ptr: number): number {
23949 if(!isWasmInitialized) {
23950 throw new Error("initializeWasm() must be awaited first!");
23952 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
23953 return nativeResponseValue;
23955 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
23957 export function ChannelUpdate_set_signature(this_ptr: number, val: number): void {
23958 if(!isWasmInitialized) {
23959 throw new Error("initializeWasm() must be awaited first!");
23961 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
23962 // debug statements here
23964 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
23966 export function ChannelUpdate_get_contents(this_ptr: number): number {
23967 if(!isWasmInitialized) {
23968 throw new Error("initializeWasm() must be awaited first!");
23970 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
23971 return nativeResponseValue;
23973 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
23975 export function ChannelUpdate_set_contents(this_ptr: number, val: number): void {
23976 if(!isWasmInitialized) {
23977 throw new Error("initializeWasm() must be awaited first!");
23979 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
23980 // debug statements here
23982 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
23984 export function ChannelUpdate_new(signature_arg: number, contents_arg: number): number {
23985 if(!isWasmInitialized) {
23986 throw new Error("initializeWasm() must be awaited first!");
23988 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
23989 return nativeResponseValue;
23991 // uintptr_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
23993 export function ChannelUpdate_clone_ptr(arg: number): number {
23994 if(!isWasmInitialized) {
23995 throw new Error("initializeWasm() must be awaited first!");
23997 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
23998 return nativeResponseValue;
24000 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
24002 export function ChannelUpdate_clone(orig: number): number {
24003 if(!isWasmInitialized) {
24004 throw new Error("initializeWasm() must be awaited first!");
24006 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
24007 return nativeResponseValue;
24009 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
24011 export function QueryChannelRange_free(this_obj: number): void {
24012 if(!isWasmInitialized) {
24013 throw new Error("initializeWasm() must be awaited first!");
24015 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
24016 // debug statements here
24018 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
24020 export function QueryChannelRange_get_chain_hash(this_ptr: number): number {
24021 if(!isWasmInitialized) {
24022 throw new Error("initializeWasm() must be awaited first!");
24024 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
24025 return nativeResponseValue;
24027 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24029 export function QueryChannelRange_set_chain_hash(this_ptr: number, val: number): void {
24030 if(!isWasmInitialized) {
24031 throw new Error("initializeWasm() must be awaited first!");
24033 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
24034 // debug statements here
24036 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
24038 export function QueryChannelRange_get_first_blocknum(this_ptr: number): number {
24039 if(!isWasmInitialized) {
24040 throw new Error("initializeWasm() must be awaited first!");
24042 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
24043 return nativeResponseValue;
24045 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
24047 export function QueryChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
24048 if(!isWasmInitialized) {
24049 throw new Error("initializeWasm() must be awaited first!");
24051 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
24052 // debug statements here
24054 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
24056 export function QueryChannelRange_get_number_of_blocks(this_ptr: number): number {
24057 if(!isWasmInitialized) {
24058 throw new Error("initializeWasm() must be awaited first!");
24060 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
24061 return nativeResponseValue;
24063 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
24065 export function QueryChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
24066 if(!isWasmInitialized) {
24067 throw new Error("initializeWasm() must be awaited first!");
24069 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
24070 // debug statements here
24072 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
24074 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): number {
24075 if(!isWasmInitialized) {
24076 throw new Error("initializeWasm() must be awaited first!");
24078 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
24079 return nativeResponseValue;
24081 // uintptr_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
24083 export function QueryChannelRange_clone_ptr(arg: number): number {
24084 if(!isWasmInitialized) {
24085 throw new Error("initializeWasm() must be awaited first!");
24087 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
24088 return nativeResponseValue;
24090 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
24092 export function QueryChannelRange_clone(orig: number): number {
24093 if(!isWasmInitialized) {
24094 throw new Error("initializeWasm() must be awaited first!");
24096 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
24097 return nativeResponseValue;
24099 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
24101 export function ReplyChannelRange_free(this_obj: number): void {
24102 if(!isWasmInitialized) {
24103 throw new Error("initializeWasm() must be awaited first!");
24105 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
24106 // debug statements here
24108 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
24110 export function ReplyChannelRange_get_chain_hash(this_ptr: number): number {
24111 if(!isWasmInitialized) {
24112 throw new Error("initializeWasm() must be awaited first!");
24114 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
24115 return nativeResponseValue;
24117 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24119 export function ReplyChannelRange_set_chain_hash(this_ptr: number, val: number): void {
24120 if(!isWasmInitialized) {
24121 throw new Error("initializeWasm() must be awaited first!");
24123 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
24124 // debug statements here
24126 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
24128 export function ReplyChannelRange_get_first_blocknum(this_ptr: number): number {
24129 if(!isWasmInitialized) {
24130 throw new Error("initializeWasm() must be awaited first!");
24132 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
24133 return nativeResponseValue;
24135 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
24137 export function ReplyChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
24138 if(!isWasmInitialized) {
24139 throw new Error("initializeWasm() must be awaited first!");
24141 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
24142 // debug statements here
24144 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
24146 export function ReplyChannelRange_get_number_of_blocks(this_ptr: number): number {
24147 if(!isWasmInitialized) {
24148 throw new Error("initializeWasm() must be awaited first!");
24150 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
24151 return nativeResponseValue;
24153 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
24155 export function ReplyChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
24156 if(!isWasmInitialized) {
24157 throw new Error("initializeWasm() must be awaited first!");
24159 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
24160 // debug statements here
24162 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
24164 export function ReplyChannelRange_get_sync_complete(this_ptr: number): boolean {
24165 if(!isWasmInitialized) {
24166 throw new Error("initializeWasm() must be awaited first!");
24168 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
24169 return nativeResponseValue;
24171 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
24173 export function ReplyChannelRange_set_sync_complete(this_ptr: number, val: boolean): void {
24174 if(!isWasmInitialized) {
24175 throw new Error("initializeWasm() must be awaited first!");
24177 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
24178 // debug statements here
24180 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
24182 export function ReplyChannelRange_set_short_channel_ids(this_ptr: number, val: number): void {
24183 if(!isWasmInitialized) {
24184 throw new Error("initializeWasm() must be awaited first!");
24186 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
24187 // debug statements here
24189 // 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);
24191 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 {
24192 if(!isWasmInitialized) {
24193 throw new Error("initializeWasm() must be awaited first!");
24195 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
24196 return nativeResponseValue;
24198 // uintptr_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
24200 export function ReplyChannelRange_clone_ptr(arg: number): number {
24201 if(!isWasmInitialized) {
24202 throw new Error("initializeWasm() must be awaited first!");
24204 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
24205 return nativeResponseValue;
24207 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
24209 export function ReplyChannelRange_clone(orig: number): number {
24210 if(!isWasmInitialized) {
24211 throw new Error("initializeWasm() must be awaited first!");
24213 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
24214 return nativeResponseValue;
24216 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
24218 export function QueryShortChannelIds_free(this_obj: number): void {
24219 if(!isWasmInitialized) {
24220 throw new Error("initializeWasm() must be awaited first!");
24222 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
24223 // debug statements here
24225 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
24227 export function QueryShortChannelIds_get_chain_hash(this_ptr: number): number {
24228 if(!isWasmInitialized) {
24229 throw new Error("initializeWasm() must be awaited first!");
24231 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
24232 return nativeResponseValue;
24234 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24236 export function QueryShortChannelIds_set_chain_hash(this_ptr: number, val: number): void {
24237 if(!isWasmInitialized) {
24238 throw new Error("initializeWasm() must be awaited first!");
24240 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
24241 // debug statements here
24243 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
24245 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: number, val: number): void {
24246 if(!isWasmInitialized) {
24247 throw new Error("initializeWasm() must be awaited first!");
24249 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
24250 // debug statements here
24252 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
24254 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): number {
24255 if(!isWasmInitialized) {
24256 throw new Error("initializeWasm() must be awaited first!");
24258 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
24259 return nativeResponseValue;
24261 // uintptr_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
24263 export function QueryShortChannelIds_clone_ptr(arg: number): number {
24264 if(!isWasmInitialized) {
24265 throw new Error("initializeWasm() must be awaited first!");
24267 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
24268 return nativeResponseValue;
24270 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
24272 export function QueryShortChannelIds_clone(orig: number): number {
24273 if(!isWasmInitialized) {
24274 throw new Error("initializeWasm() must be awaited first!");
24276 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
24277 return nativeResponseValue;
24279 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
24281 export function ReplyShortChannelIdsEnd_free(this_obj: number): void {
24282 if(!isWasmInitialized) {
24283 throw new Error("initializeWasm() must be awaited first!");
24285 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
24286 // debug statements here
24288 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
24290 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: number): number {
24291 if(!isWasmInitialized) {
24292 throw new Error("initializeWasm() must be awaited first!");
24294 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
24295 return nativeResponseValue;
24297 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24299 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: number, val: number): void {
24300 if(!isWasmInitialized) {
24301 throw new Error("initializeWasm() must be awaited first!");
24303 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
24304 // debug statements here
24306 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
24308 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: number): boolean {
24309 if(!isWasmInitialized) {
24310 throw new Error("initializeWasm() must be awaited first!");
24312 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
24313 return nativeResponseValue;
24315 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
24317 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: number, val: boolean): void {
24318 if(!isWasmInitialized) {
24319 throw new Error("initializeWasm() must be awaited first!");
24321 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
24322 // debug statements here
24324 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
24326 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): number {
24327 if(!isWasmInitialized) {
24328 throw new Error("initializeWasm() must be awaited first!");
24330 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
24331 return nativeResponseValue;
24333 // uintptr_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
24335 export function ReplyShortChannelIdsEnd_clone_ptr(arg: number): number {
24336 if(!isWasmInitialized) {
24337 throw new Error("initializeWasm() must be awaited first!");
24339 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
24340 return nativeResponseValue;
24342 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
24344 export function ReplyShortChannelIdsEnd_clone(orig: number): number {
24345 if(!isWasmInitialized) {
24346 throw new Error("initializeWasm() must be awaited first!");
24348 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
24349 return nativeResponseValue;
24351 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
24353 export function GossipTimestampFilter_free(this_obj: number): void {
24354 if(!isWasmInitialized) {
24355 throw new Error("initializeWasm() must be awaited first!");
24357 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
24358 // debug statements here
24360 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
24362 export function GossipTimestampFilter_get_chain_hash(this_ptr: number): number {
24363 if(!isWasmInitialized) {
24364 throw new Error("initializeWasm() must be awaited first!");
24366 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
24367 return nativeResponseValue;
24369 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
24371 export function GossipTimestampFilter_set_chain_hash(this_ptr: number, val: number): void {
24372 if(!isWasmInitialized) {
24373 throw new Error("initializeWasm() must be awaited first!");
24375 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
24376 // debug statements here
24378 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
24380 export function GossipTimestampFilter_get_first_timestamp(this_ptr: number): number {
24381 if(!isWasmInitialized) {
24382 throw new Error("initializeWasm() must be awaited first!");
24384 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
24385 return nativeResponseValue;
24387 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
24389 export function GossipTimestampFilter_set_first_timestamp(this_ptr: number, val: number): void {
24390 if(!isWasmInitialized) {
24391 throw new Error("initializeWasm() must be awaited first!");
24393 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
24394 // debug statements here
24396 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
24398 export function GossipTimestampFilter_get_timestamp_range(this_ptr: number): number {
24399 if(!isWasmInitialized) {
24400 throw new Error("initializeWasm() must be awaited first!");
24402 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
24403 return nativeResponseValue;
24405 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
24407 export function GossipTimestampFilter_set_timestamp_range(this_ptr: number, val: number): void {
24408 if(!isWasmInitialized) {
24409 throw new Error("initializeWasm() must be awaited first!");
24411 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
24412 // debug statements here
24414 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
24416 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): number {
24417 if(!isWasmInitialized) {
24418 throw new Error("initializeWasm() must be awaited first!");
24420 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
24421 return nativeResponseValue;
24423 // uintptr_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
24425 export function GossipTimestampFilter_clone_ptr(arg: number): number {
24426 if(!isWasmInitialized) {
24427 throw new Error("initializeWasm() must be awaited first!");
24429 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
24430 return nativeResponseValue;
24432 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
24434 export function GossipTimestampFilter_clone(orig: number): number {
24435 if(!isWasmInitialized) {
24436 throw new Error("initializeWasm() must be awaited first!");
24438 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
24439 return nativeResponseValue;
24441 // void ErrorAction_free(struct LDKErrorAction this_ptr);
24443 export function ErrorAction_free(this_ptr: number): void {
24444 if(!isWasmInitialized) {
24445 throw new Error("initializeWasm() must be awaited first!");
24447 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
24448 // debug statements here
24450 // uintptr_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
24452 export function ErrorAction_clone_ptr(arg: number): number {
24453 if(!isWasmInitialized) {
24454 throw new Error("initializeWasm() must be awaited first!");
24456 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
24457 return nativeResponseValue;
24459 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
24461 export function ErrorAction_clone(orig: number): number {
24462 if(!isWasmInitialized) {
24463 throw new Error("initializeWasm() must be awaited first!");
24465 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
24466 return nativeResponseValue;
24468 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
24470 export function ErrorAction_disconnect_peer(msg: number): number {
24471 if(!isWasmInitialized) {
24472 throw new Error("initializeWasm() must be awaited first!");
24474 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
24475 return nativeResponseValue;
24477 // struct LDKErrorAction ErrorAction_ignore_error(void);
24479 export function ErrorAction_ignore_error(): number {
24480 if(!isWasmInitialized) {
24481 throw new Error("initializeWasm() must be awaited first!");
24483 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
24484 return nativeResponseValue;
24486 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
24488 export function ErrorAction_ignore_and_log(a: Level): number {
24489 if(!isWasmInitialized) {
24490 throw new Error("initializeWasm() must be awaited first!");
24492 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
24493 return nativeResponseValue;
24495 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
24497 export function ErrorAction_ignore_duplicate_gossip(): number {
24498 if(!isWasmInitialized) {
24499 throw new Error("initializeWasm() must be awaited first!");
24501 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
24502 return nativeResponseValue;
24504 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
24506 export function ErrorAction_send_error_message(msg: number): number {
24507 if(!isWasmInitialized) {
24508 throw new Error("initializeWasm() must be awaited first!");
24510 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
24511 return nativeResponseValue;
24513 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
24515 export function ErrorAction_send_warning_message(msg: number, log_level: Level): number {
24516 if(!isWasmInitialized) {
24517 throw new Error("initializeWasm() must be awaited first!");
24519 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
24520 return nativeResponseValue;
24522 // void LightningError_free(struct LDKLightningError this_obj);
24524 export function LightningError_free(this_obj: number): void {
24525 if(!isWasmInitialized) {
24526 throw new Error("initializeWasm() must be awaited first!");
24528 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
24529 // debug statements here
24531 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
24533 export function LightningError_get_err(this_ptr: number): number {
24534 if(!isWasmInitialized) {
24535 throw new Error("initializeWasm() must be awaited first!");
24537 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
24538 return nativeResponseValue;
24540 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
24542 export function LightningError_set_err(this_ptr: number, val: number): void {
24543 if(!isWasmInitialized) {
24544 throw new Error("initializeWasm() must be awaited first!");
24546 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
24547 // debug statements here
24549 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
24551 export function LightningError_get_action(this_ptr: number): number {
24552 if(!isWasmInitialized) {
24553 throw new Error("initializeWasm() must be awaited first!");
24555 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
24556 return nativeResponseValue;
24558 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
24560 export function LightningError_set_action(this_ptr: number, val: number): void {
24561 if(!isWasmInitialized) {
24562 throw new Error("initializeWasm() must be awaited first!");
24564 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
24565 // debug statements here
24567 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
24569 export function LightningError_new(err_arg: number, action_arg: number): number {
24570 if(!isWasmInitialized) {
24571 throw new Error("initializeWasm() must be awaited first!");
24573 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
24574 return nativeResponseValue;
24576 // uintptr_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
24578 export function LightningError_clone_ptr(arg: number): number {
24579 if(!isWasmInitialized) {
24580 throw new Error("initializeWasm() must be awaited first!");
24582 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
24583 return nativeResponseValue;
24585 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
24587 export function LightningError_clone(orig: number): number {
24588 if(!isWasmInitialized) {
24589 throw new Error("initializeWasm() must be awaited first!");
24591 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
24592 return nativeResponseValue;
24594 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
24596 export function CommitmentUpdate_free(this_obj: number): void {
24597 if(!isWasmInitialized) {
24598 throw new Error("initializeWasm() must be awaited first!");
24600 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
24601 // debug statements here
24603 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24605 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: number): number {
24606 if(!isWasmInitialized) {
24607 throw new Error("initializeWasm() must be awaited first!");
24609 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
24610 return nativeResponseValue;
24612 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
24614 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: number, val: number): void {
24615 if(!isWasmInitialized) {
24616 throw new Error("initializeWasm() must be awaited first!");
24618 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
24619 // debug statements here
24621 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24623 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: number): number {
24624 if(!isWasmInitialized) {
24625 throw new Error("initializeWasm() must be awaited first!");
24627 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
24628 return nativeResponseValue;
24630 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
24632 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: number, val: number): void {
24633 if(!isWasmInitialized) {
24634 throw new Error("initializeWasm() must be awaited first!");
24636 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
24637 // debug statements here
24639 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24641 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: number): number {
24642 if(!isWasmInitialized) {
24643 throw new Error("initializeWasm() must be awaited first!");
24645 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
24646 return nativeResponseValue;
24648 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
24650 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: number, val: number): void {
24651 if(!isWasmInitialized) {
24652 throw new Error("initializeWasm() must be awaited first!");
24654 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
24655 // debug statements here
24657 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24659 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: number): number {
24660 if(!isWasmInitialized) {
24661 throw new Error("initializeWasm() must be awaited first!");
24663 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
24664 return nativeResponseValue;
24666 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
24668 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: number, val: number): void {
24669 if(!isWasmInitialized) {
24670 throw new Error("initializeWasm() must be awaited first!");
24672 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
24673 // debug statements here
24675 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24677 export function CommitmentUpdate_get_update_fee(this_ptr: number): number {
24678 if(!isWasmInitialized) {
24679 throw new Error("initializeWasm() must be awaited first!");
24681 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
24682 return nativeResponseValue;
24684 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
24686 export function CommitmentUpdate_set_update_fee(this_ptr: number, val: number): void {
24687 if(!isWasmInitialized) {
24688 throw new Error("initializeWasm() must be awaited first!");
24690 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
24691 // debug statements here
24693 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24695 export function CommitmentUpdate_get_commitment_signed(this_ptr: number): number {
24696 if(!isWasmInitialized) {
24697 throw new Error("initializeWasm() must be awaited first!");
24699 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
24700 return nativeResponseValue;
24702 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
24704 export function CommitmentUpdate_set_commitment_signed(this_ptr: number, val: number): void {
24705 if(!isWasmInitialized) {
24706 throw new Error("initializeWasm() must be awaited first!");
24708 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
24709 // debug statements here
24711 // 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);
24713 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 {
24714 if(!isWasmInitialized) {
24715 throw new Error("initializeWasm() must be awaited first!");
24717 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);
24718 return nativeResponseValue;
24720 // uintptr_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
24722 export function CommitmentUpdate_clone_ptr(arg: number): number {
24723 if(!isWasmInitialized) {
24724 throw new Error("initializeWasm() must be awaited first!");
24726 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
24727 return nativeResponseValue;
24729 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
24731 export function CommitmentUpdate_clone(orig: number): number {
24732 if(!isWasmInitialized) {
24733 throw new Error("initializeWasm() must be awaited first!");
24735 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
24736 return nativeResponseValue;
24738 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
24740 export function ChannelMessageHandler_free(this_ptr: number): void {
24741 if(!isWasmInitialized) {
24742 throw new Error("initializeWasm() must be awaited first!");
24744 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
24745 // debug statements here
24747 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
24749 export function RoutingMessageHandler_free(this_ptr: number): void {
24750 if(!isWasmInitialized) {
24751 throw new Error("initializeWasm() must be awaited first!");
24753 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
24754 // debug statements here
24756 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
24758 export function AcceptChannel_write(obj: number): number {
24759 if(!isWasmInitialized) {
24760 throw new Error("initializeWasm() must be awaited first!");
24762 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
24763 return nativeResponseValue;
24765 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
24767 export function AcceptChannel_read(ser: number): number {
24768 if(!isWasmInitialized) {
24769 throw new Error("initializeWasm() must be awaited first!");
24771 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
24772 return nativeResponseValue;
24774 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
24776 export function AnnouncementSignatures_write(obj: number): number {
24777 if(!isWasmInitialized) {
24778 throw new Error("initializeWasm() must be awaited first!");
24780 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
24781 return nativeResponseValue;
24783 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
24785 export function AnnouncementSignatures_read(ser: number): number {
24786 if(!isWasmInitialized) {
24787 throw new Error("initializeWasm() must be awaited first!");
24789 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
24790 return nativeResponseValue;
24792 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
24794 export function ChannelReestablish_write(obj: number): number {
24795 if(!isWasmInitialized) {
24796 throw new Error("initializeWasm() must be awaited first!");
24798 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
24799 return nativeResponseValue;
24801 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
24803 export function ChannelReestablish_read(ser: number): number {
24804 if(!isWasmInitialized) {
24805 throw new Error("initializeWasm() must be awaited first!");
24807 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
24808 return nativeResponseValue;
24810 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
24812 export function ClosingSigned_write(obj: number): number {
24813 if(!isWasmInitialized) {
24814 throw new Error("initializeWasm() must be awaited first!");
24816 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
24817 return nativeResponseValue;
24819 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
24821 export function ClosingSigned_read(ser: number): number {
24822 if(!isWasmInitialized) {
24823 throw new Error("initializeWasm() must be awaited first!");
24825 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
24826 return nativeResponseValue;
24828 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
24830 export function ClosingSignedFeeRange_write(obj: number): number {
24831 if(!isWasmInitialized) {
24832 throw new Error("initializeWasm() must be awaited first!");
24834 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
24835 return nativeResponseValue;
24837 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
24839 export function ClosingSignedFeeRange_read(ser: number): number {
24840 if(!isWasmInitialized) {
24841 throw new Error("initializeWasm() must be awaited first!");
24843 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
24844 return nativeResponseValue;
24846 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
24848 export function CommitmentSigned_write(obj: number): number {
24849 if(!isWasmInitialized) {
24850 throw new Error("initializeWasm() must be awaited first!");
24852 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
24853 return nativeResponseValue;
24855 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
24857 export function CommitmentSigned_read(ser: number): number {
24858 if(!isWasmInitialized) {
24859 throw new Error("initializeWasm() must be awaited first!");
24861 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
24862 return nativeResponseValue;
24864 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
24866 export function FundingCreated_write(obj: number): number {
24867 if(!isWasmInitialized) {
24868 throw new Error("initializeWasm() must be awaited first!");
24870 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
24871 return nativeResponseValue;
24873 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
24875 export function FundingCreated_read(ser: number): number {
24876 if(!isWasmInitialized) {
24877 throw new Error("initializeWasm() must be awaited first!");
24879 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
24880 return nativeResponseValue;
24882 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
24884 export function FundingSigned_write(obj: number): number {
24885 if(!isWasmInitialized) {
24886 throw new Error("initializeWasm() must be awaited first!");
24888 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
24889 return nativeResponseValue;
24891 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
24893 export function FundingSigned_read(ser: number): number {
24894 if(!isWasmInitialized) {
24895 throw new Error("initializeWasm() must be awaited first!");
24897 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
24898 return nativeResponseValue;
24900 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
24902 export function ChannelReady_write(obj: number): number {
24903 if(!isWasmInitialized) {
24904 throw new Error("initializeWasm() must be awaited first!");
24906 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
24907 return nativeResponseValue;
24909 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
24911 export function ChannelReady_read(ser: number): number {
24912 if(!isWasmInitialized) {
24913 throw new Error("initializeWasm() must be awaited first!");
24915 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
24916 return nativeResponseValue;
24918 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
24920 export function Init_write(obj: number): number {
24921 if(!isWasmInitialized) {
24922 throw new Error("initializeWasm() must be awaited first!");
24924 const nativeResponseValue = wasm.TS_Init_write(obj);
24925 return nativeResponseValue;
24927 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
24929 export function Init_read(ser: number): number {
24930 if(!isWasmInitialized) {
24931 throw new Error("initializeWasm() must be awaited first!");
24933 const nativeResponseValue = wasm.TS_Init_read(ser);
24934 return nativeResponseValue;
24936 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
24938 export function OpenChannel_write(obj: number): number {
24939 if(!isWasmInitialized) {
24940 throw new Error("initializeWasm() must be awaited first!");
24942 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
24943 return nativeResponseValue;
24945 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
24947 export function OpenChannel_read(ser: number): number {
24948 if(!isWasmInitialized) {
24949 throw new Error("initializeWasm() must be awaited first!");
24951 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
24952 return nativeResponseValue;
24954 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
24956 export function RevokeAndACK_write(obj: number): number {
24957 if(!isWasmInitialized) {
24958 throw new Error("initializeWasm() must be awaited first!");
24960 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
24961 return nativeResponseValue;
24963 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
24965 export function RevokeAndACK_read(ser: number): number {
24966 if(!isWasmInitialized) {
24967 throw new Error("initializeWasm() must be awaited first!");
24969 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
24970 return nativeResponseValue;
24972 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
24974 export function Shutdown_write(obj: number): number {
24975 if(!isWasmInitialized) {
24976 throw new Error("initializeWasm() must be awaited first!");
24978 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
24979 return nativeResponseValue;
24981 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
24983 export function Shutdown_read(ser: number): number {
24984 if(!isWasmInitialized) {
24985 throw new Error("initializeWasm() must be awaited first!");
24987 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
24988 return nativeResponseValue;
24990 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
24992 export function UpdateFailHTLC_write(obj: number): number {
24993 if(!isWasmInitialized) {
24994 throw new Error("initializeWasm() must be awaited first!");
24996 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
24997 return nativeResponseValue;
24999 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
25001 export function UpdateFailHTLC_read(ser: number): number {
25002 if(!isWasmInitialized) {
25003 throw new Error("initializeWasm() must be awaited first!");
25005 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
25006 return nativeResponseValue;
25008 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
25010 export function UpdateFailMalformedHTLC_write(obj: number): number {
25011 if(!isWasmInitialized) {
25012 throw new Error("initializeWasm() must be awaited first!");
25014 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
25015 return nativeResponseValue;
25017 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
25019 export function UpdateFailMalformedHTLC_read(ser: number): number {
25020 if(!isWasmInitialized) {
25021 throw new Error("initializeWasm() must be awaited first!");
25023 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
25024 return nativeResponseValue;
25026 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
25028 export function UpdateFee_write(obj: number): number {
25029 if(!isWasmInitialized) {
25030 throw new Error("initializeWasm() must be awaited first!");
25032 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
25033 return nativeResponseValue;
25035 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
25037 export function UpdateFee_read(ser: number): number {
25038 if(!isWasmInitialized) {
25039 throw new Error("initializeWasm() must be awaited first!");
25041 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
25042 return nativeResponseValue;
25044 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
25046 export function UpdateFulfillHTLC_write(obj: number): number {
25047 if(!isWasmInitialized) {
25048 throw new Error("initializeWasm() must be awaited first!");
25050 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
25051 return nativeResponseValue;
25053 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
25055 export function UpdateFulfillHTLC_read(ser: number): number {
25056 if(!isWasmInitialized) {
25057 throw new Error("initializeWasm() must be awaited first!");
25059 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
25060 return nativeResponseValue;
25062 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
25064 export function UpdateAddHTLC_write(obj: number): number {
25065 if(!isWasmInitialized) {
25066 throw new Error("initializeWasm() must be awaited first!");
25068 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
25069 return nativeResponseValue;
25071 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
25073 export function UpdateAddHTLC_read(ser: number): number {
25074 if(!isWasmInitialized) {
25075 throw new Error("initializeWasm() must be awaited first!");
25077 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
25078 return nativeResponseValue;
25080 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
25082 export function Ping_write(obj: number): number {
25083 if(!isWasmInitialized) {
25084 throw new Error("initializeWasm() must be awaited first!");
25086 const nativeResponseValue = wasm.TS_Ping_write(obj);
25087 return nativeResponseValue;
25089 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
25091 export function Ping_read(ser: number): number {
25092 if(!isWasmInitialized) {
25093 throw new Error("initializeWasm() must be awaited first!");
25095 const nativeResponseValue = wasm.TS_Ping_read(ser);
25096 return nativeResponseValue;
25098 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
25100 export function Pong_write(obj: number): number {
25101 if(!isWasmInitialized) {
25102 throw new Error("initializeWasm() must be awaited first!");
25104 const nativeResponseValue = wasm.TS_Pong_write(obj);
25105 return nativeResponseValue;
25107 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
25109 export function Pong_read(ser: number): number {
25110 if(!isWasmInitialized) {
25111 throw new Error("initializeWasm() must be awaited first!");
25113 const nativeResponseValue = wasm.TS_Pong_read(ser);
25114 return nativeResponseValue;
25116 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
25118 export function UnsignedChannelAnnouncement_write(obj: number): number {
25119 if(!isWasmInitialized) {
25120 throw new Error("initializeWasm() must be awaited first!");
25122 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
25123 return nativeResponseValue;
25125 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
25127 export function UnsignedChannelAnnouncement_read(ser: number): number {
25128 if(!isWasmInitialized) {
25129 throw new Error("initializeWasm() must be awaited first!");
25131 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
25132 return nativeResponseValue;
25134 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
25136 export function ChannelAnnouncement_write(obj: number): number {
25137 if(!isWasmInitialized) {
25138 throw new Error("initializeWasm() must be awaited first!");
25140 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
25141 return nativeResponseValue;
25143 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
25145 export function ChannelAnnouncement_read(ser: number): number {
25146 if(!isWasmInitialized) {
25147 throw new Error("initializeWasm() must be awaited first!");
25149 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
25150 return nativeResponseValue;
25152 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
25154 export function UnsignedChannelUpdate_write(obj: number): number {
25155 if(!isWasmInitialized) {
25156 throw new Error("initializeWasm() must be awaited first!");
25158 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
25159 return nativeResponseValue;
25161 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
25163 export function UnsignedChannelUpdate_read(ser: number): number {
25164 if(!isWasmInitialized) {
25165 throw new Error("initializeWasm() must be awaited first!");
25167 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
25168 return nativeResponseValue;
25170 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
25172 export function ChannelUpdate_write(obj: number): number {
25173 if(!isWasmInitialized) {
25174 throw new Error("initializeWasm() must be awaited first!");
25176 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
25177 return nativeResponseValue;
25179 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
25181 export function ChannelUpdate_read(ser: number): number {
25182 if(!isWasmInitialized) {
25183 throw new Error("initializeWasm() must be awaited first!");
25185 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
25186 return nativeResponseValue;
25188 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
25190 export function ErrorMessage_write(obj: number): number {
25191 if(!isWasmInitialized) {
25192 throw new Error("initializeWasm() must be awaited first!");
25194 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
25195 return nativeResponseValue;
25197 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
25199 export function ErrorMessage_read(ser: number): number {
25200 if(!isWasmInitialized) {
25201 throw new Error("initializeWasm() must be awaited first!");
25203 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
25204 return nativeResponseValue;
25206 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
25208 export function WarningMessage_write(obj: number): number {
25209 if(!isWasmInitialized) {
25210 throw new Error("initializeWasm() must be awaited first!");
25212 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
25213 return nativeResponseValue;
25215 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
25217 export function WarningMessage_read(ser: number): number {
25218 if(!isWasmInitialized) {
25219 throw new Error("initializeWasm() must be awaited first!");
25221 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
25222 return nativeResponseValue;
25224 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
25226 export function UnsignedNodeAnnouncement_write(obj: number): number {
25227 if(!isWasmInitialized) {
25228 throw new Error("initializeWasm() must be awaited first!");
25230 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
25231 return nativeResponseValue;
25233 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
25235 export function UnsignedNodeAnnouncement_read(ser: number): number {
25236 if(!isWasmInitialized) {
25237 throw new Error("initializeWasm() must be awaited first!");
25239 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
25240 return nativeResponseValue;
25242 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
25244 export function NodeAnnouncement_write(obj: number): number {
25245 if(!isWasmInitialized) {
25246 throw new Error("initializeWasm() must be awaited first!");
25248 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
25249 return nativeResponseValue;
25251 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
25253 export function NodeAnnouncement_read(ser: number): number {
25254 if(!isWasmInitialized) {
25255 throw new Error("initializeWasm() must be awaited first!");
25257 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
25258 return nativeResponseValue;
25260 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
25262 export function QueryShortChannelIds_read(ser: number): number {
25263 if(!isWasmInitialized) {
25264 throw new Error("initializeWasm() must be awaited first!");
25266 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
25267 return nativeResponseValue;
25269 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
25271 export function QueryShortChannelIds_write(obj: number): number {
25272 if(!isWasmInitialized) {
25273 throw new Error("initializeWasm() must be awaited first!");
25275 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
25276 return nativeResponseValue;
25278 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
25280 export function ReplyShortChannelIdsEnd_write(obj: number): number {
25281 if(!isWasmInitialized) {
25282 throw new Error("initializeWasm() must be awaited first!");
25284 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
25285 return nativeResponseValue;
25287 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
25289 export function ReplyShortChannelIdsEnd_read(ser: number): number {
25290 if(!isWasmInitialized) {
25291 throw new Error("initializeWasm() must be awaited first!");
25293 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
25294 return nativeResponseValue;
25296 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
25298 export function QueryChannelRange_end_blocknum(this_arg: number): number {
25299 if(!isWasmInitialized) {
25300 throw new Error("initializeWasm() must be awaited first!");
25302 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
25303 return nativeResponseValue;
25305 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
25307 export function QueryChannelRange_write(obj: number): number {
25308 if(!isWasmInitialized) {
25309 throw new Error("initializeWasm() must be awaited first!");
25311 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
25312 return nativeResponseValue;
25314 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
25316 export function QueryChannelRange_read(ser: number): number {
25317 if(!isWasmInitialized) {
25318 throw new Error("initializeWasm() must be awaited first!");
25320 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
25321 return nativeResponseValue;
25323 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
25325 export function ReplyChannelRange_read(ser: number): number {
25326 if(!isWasmInitialized) {
25327 throw new Error("initializeWasm() must be awaited first!");
25329 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
25330 return nativeResponseValue;
25332 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
25334 export function ReplyChannelRange_write(obj: number): number {
25335 if(!isWasmInitialized) {
25336 throw new Error("initializeWasm() must be awaited first!");
25338 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
25339 return nativeResponseValue;
25341 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
25343 export function GossipTimestampFilter_write(obj: number): number {
25344 if(!isWasmInitialized) {
25345 throw new Error("initializeWasm() must be awaited first!");
25347 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
25348 return nativeResponseValue;
25350 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
25352 export function GossipTimestampFilter_read(ser: number): number {
25353 if(!isWasmInitialized) {
25354 throw new Error("initializeWasm() must be awaited first!");
25356 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
25357 return nativeResponseValue;
25359 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
25361 export function CustomMessageHandler_free(this_ptr: number): void {
25362 if(!isWasmInitialized) {
25363 throw new Error("initializeWasm() must be awaited first!");
25365 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
25366 // debug statements here
25368 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
25370 export function IgnoringMessageHandler_free(this_obj: number): void {
25371 if(!isWasmInitialized) {
25372 throw new Error("initializeWasm() must be awaited first!");
25374 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
25375 // debug statements here
25377 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
25379 export function IgnoringMessageHandler_new(): number {
25380 if(!isWasmInitialized) {
25381 throw new Error("initializeWasm() must be awaited first!");
25383 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
25384 return nativeResponseValue;
25386 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
25388 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
25389 if(!isWasmInitialized) {
25390 throw new Error("initializeWasm() must be awaited first!");
25392 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
25393 return nativeResponseValue;
25395 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
25397 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
25398 if(!isWasmInitialized) {
25399 throw new Error("initializeWasm() must be awaited first!");
25401 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
25402 return nativeResponseValue;
25404 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
25406 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: number): number {
25407 if(!isWasmInitialized) {
25408 throw new Error("initializeWasm() must be awaited first!");
25410 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
25411 return nativeResponseValue;
25413 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
25415 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: number): number {
25416 if(!isWasmInitialized) {
25417 throw new Error("initializeWasm() must be awaited first!");
25419 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
25420 return nativeResponseValue;
25422 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
25424 export function ErroringMessageHandler_free(this_obj: number): void {
25425 if(!isWasmInitialized) {
25426 throw new Error("initializeWasm() must be awaited first!");
25428 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
25429 // debug statements here
25431 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
25433 export function ErroringMessageHandler_new(): number {
25434 if(!isWasmInitialized) {
25435 throw new Error("initializeWasm() must be awaited first!");
25437 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
25438 return nativeResponseValue;
25440 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
25442 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
25443 if(!isWasmInitialized) {
25444 throw new Error("initializeWasm() must be awaited first!");
25446 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
25447 return nativeResponseValue;
25449 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
25451 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
25452 if(!isWasmInitialized) {
25453 throw new Error("initializeWasm() must be awaited first!");
25455 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
25456 return nativeResponseValue;
25458 // void MessageHandler_free(struct LDKMessageHandler this_obj);
25460 export function MessageHandler_free(this_obj: number): void {
25461 if(!isWasmInitialized) {
25462 throw new Error("initializeWasm() must be awaited first!");
25464 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
25465 // debug statements here
25467 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
25469 export function MessageHandler_get_chan_handler(this_ptr: number): number {
25470 if(!isWasmInitialized) {
25471 throw new Error("initializeWasm() must be awaited first!");
25473 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
25474 return nativeResponseValue;
25476 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
25478 export function MessageHandler_set_chan_handler(this_ptr: number, val: number): void {
25479 if(!isWasmInitialized) {
25480 throw new Error("initializeWasm() must be awaited first!");
25482 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
25483 // debug statements here
25485 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
25487 export function MessageHandler_get_route_handler(this_ptr: number): number {
25488 if(!isWasmInitialized) {
25489 throw new Error("initializeWasm() must be awaited first!");
25491 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
25492 return nativeResponseValue;
25494 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
25496 export function MessageHandler_set_route_handler(this_ptr: number, val: number): void {
25497 if(!isWasmInitialized) {
25498 throw new Error("initializeWasm() must be awaited first!");
25500 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
25501 // debug statements here
25503 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
25505 export function MessageHandler_new(chan_handler_arg: number, route_handler_arg: number): number {
25506 if(!isWasmInitialized) {
25507 throw new Error("initializeWasm() must be awaited first!");
25509 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg);
25510 return nativeResponseValue;
25512 // uintptr_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
25514 export function SocketDescriptor_clone_ptr(arg: number): number {
25515 if(!isWasmInitialized) {
25516 throw new Error("initializeWasm() must be awaited first!");
25518 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
25519 return nativeResponseValue;
25521 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
25523 export function SocketDescriptor_clone(orig: number): number {
25524 if(!isWasmInitialized) {
25525 throw new Error("initializeWasm() must be awaited first!");
25527 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
25528 return nativeResponseValue;
25530 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
25532 export function SocketDescriptor_free(this_ptr: number): void {
25533 if(!isWasmInitialized) {
25534 throw new Error("initializeWasm() must be awaited first!");
25536 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
25537 // debug statements here
25539 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
25541 export function PeerHandleError_free(this_obj: number): void {
25542 if(!isWasmInitialized) {
25543 throw new Error("initializeWasm() must be awaited first!");
25545 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
25546 // debug statements here
25548 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
25550 export function PeerHandleError_get_no_connection_possible(this_ptr: number): boolean {
25551 if(!isWasmInitialized) {
25552 throw new Error("initializeWasm() must be awaited first!");
25554 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
25555 return nativeResponseValue;
25557 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
25559 export function PeerHandleError_set_no_connection_possible(this_ptr: number, val: boolean): void {
25560 if(!isWasmInitialized) {
25561 throw new Error("initializeWasm() must be awaited first!");
25563 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
25564 // debug statements here
25566 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
25568 export function PeerHandleError_new(no_connection_possible_arg: boolean): number {
25569 if(!isWasmInitialized) {
25570 throw new Error("initializeWasm() must be awaited first!");
25572 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
25573 return nativeResponseValue;
25575 // uintptr_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
25577 export function PeerHandleError_clone_ptr(arg: number): number {
25578 if(!isWasmInitialized) {
25579 throw new Error("initializeWasm() must be awaited first!");
25581 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
25582 return nativeResponseValue;
25584 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
25586 export function PeerHandleError_clone(orig: number): number {
25587 if(!isWasmInitialized) {
25588 throw new Error("initializeWasm() must be awaited first!");
25590 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
25591 return nativeResponseValue;
25593 // void PeerManager_free(struct LDKPeerManager this_obj);
25595 export function PeerManager_free(this_obj: number): void {
25596 if(!isWasmInitialized) {
25597 throw new Error("initializeWasm() must be awaited first!");
25599 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
25600 // debug statements here
25602 // 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);
25604 export function PeerManager_new(message_handler: number, our_node_secret: number, ephemeral_random_data: number, logger: number, custom_message_handler: number): number {
25605 if(!isWasmInitialized) {
25606 throw new Error("initializeWasm() must be awaited first!");
25608 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, ephemeral_random_data, logger, custom_message_handler);
25609 return nativeResponseValue;
25611 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
25613 export function PeerManager_get_peer_node_ids(this_arg: number): number {
25614 if(!isWasmInitialized) {
25615 throw new Error("initializeWasm() must be awaited first!");
25617 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
25618 return nativeResponseValue;
25620 // 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);
25622 export function PeerManager_new_outbound_connection(this_arg: number, their_node_id: number, descriptor: number, remote_network_address: number): number {
25623 if(!isWasmInitialized) {
25624 throw new Error("initializeWasm() must be awaited first!");
25626 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
25627 return nativeResponseValue;
25629 // 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);
25631 export function PeerManager_new_inbound_connection(this_arg: number, descriptor: number, remote_network_address: number): number {
25632 if(!isWasmInitialized) {
25633 throw new Error("initializeWasm() must be awaited first!");
25635 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
25636 return nativeResponseValue;
25638 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
25640 export function PeerManager_write_buffer_space_avail(this_arg: number, descriptor: number): number {
25641 if(!isWasmInitialized) {
25642 throw new Error("initializeWasm() must be awaited first!");
25644 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
25645 return nativeResponseValue;
25647 // 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);
25649 export function PeerManager_read_event(this_arg: number, peer_descriptor: number, data: number): number {
25650 if(!isWasmInitialized) {
25651 throw new Error("initializeWasm() must be awaited first!");
25653 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
25654 return nativeResponseValue;
25656 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
25658 export function PeerManager_process_events(this_arg: number): void {
25659 if(!isWasmInitialized) {
25660 throw new Error("initializeWasm() must be awaited first!");
25662 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
25663 // debug statements here
25665 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
25667 export function PeerManager_socket_disconnected(this_arg: number, descriptor: number): void {
25668 if(!isWasmInitialized) {
25669 throw new Error("initializeWasm() must be awaited first!");
25671 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
25672 // debug statements here
25674 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
25676 export function PeerManager_disconnect_by_node_id(this_arg: number, node_id: number, no_connection_possible: boolean): void {
25677 if(!isWasmInitialized) {
25678 throw new Error("initializeWasm() must be awaited first!");
25680 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
25681 // debug statements here
25683 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
25685 export function PeerManager_disconnect_all_peers(this_arg: number): void {
25686 if(!isWasmInitialized) {
25687 throw new Error("initializeWasm() must be awaited first!");
25689 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
25690 // debug statements here
25692 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
25694 export function PeerManager_timer_tick_occurred(this_arg: number): void {
25695 if(!isWasmInitialized) {
25696 throw new Error("initializeWasm() must be awaited first!");
25698 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
25699 // debug statements here
25701 // uint64_t htlc_success_tx_weight(bool opt_anchors);
25703 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
25704 if(!isWasmInitialized) {
25705 throw new Error("initializeWasm() must be awaited first!");
25707 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
25708 return nativeResponseValue;
25710 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
25712 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
25713 if(!isWasmInitialized) {
25714 throw new Error("initializeWasm() must be awaited first!");
25716 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
25717 return nativeResponseValue;
25719 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
25721 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
25722 if(!isWasmInitialized) {
25723 throw new Error("initializeWasm() must be awaited first!");
25725 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
25726 return nativeResponseValue;
25728 // 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);
25730 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 {
25731 if(!isWasmInitialized) {
25732 throw new Error("initializeWasm() must be awaited first!");
25734 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
25735 return nativeResponseValue;
25737 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
25739 export function CounterpartyCommitmentSecrets_free(this_obj: number): void {
25740 if(!isWasmInitialized) {
25741 throw new Error("initializeWasm() must be awaited first!");
25743 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
25744 // debug statements here
25746 // uintptr_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
25748 export function CounterpartyCommitmentSecrets_clone_ptr(arg: number): number {
25749 if(!isWasmInitialized) {
25750 throw new Error("initializeWasm() must be awaited first!");
25752 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
25753 return nativeResponseValue;
25755 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
25757 export function CounterpartyCommitmentSecrets_clone(orig: number): number {
25758 if(!isWasmInitialized) {
25759 throw new Error("initializeWasm() must be awaited first!");
25761 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
25762 return nativeResponseValue;
25764 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
25766 export function CounterpartyCommitmentSecrets_new(): number {
25767 if(!isWasmInitialized) {
25768 throw new Error("initializeWasm() must be awaited first!");
25770 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
25771 return nativeResponseValue;
25773 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
25775 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: number): bigint {
25776 if(!isWasmInitialized) {
25777 throw new Error("initializeWasm() must be awaited first!");
25779 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
25780 return nativeResponseValue;
25782 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
25784 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: number, idx: bigint, secret: number): number {
25785 if(!isWasmInitialized) {
25786 throw new Error("initializeWasm() must be awaited first!");
25788 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
25789 return nativeResponseValue;
25791 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
25793 export function CounterpartyCommitmentSecrets_get_secret(this_arg: number, idx: bigint): number {
25794 if(!isWasmInitialized) {
25795 throw new Error("initializeWasm() must be awaited first!");
25797 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
25798 return nativeResponseValue;
25800 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
25802 export function CounterpartyCommitmentSecrets_write(obj: number): number {
25803 if(!isWasmInitialized) {
25804 throw new Error("initializeWasm() must be awaited first!");
25806 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
25807 return nativeResponseValue;
25809 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
25811 export function CounterpartyCommitmentSecrets_read(ser: number): number {
25812 if(!isWasmInitialized) {
25813 throw new Error("initializeWasm() must be awaited first!");
25815 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
25816 return nativeResponseValue;
25818 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
25820 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
25821 if(!isWasmInitialized) {
25822 throw new Error("initializeWasm() must be awaited first!");
25824 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
25825 return nativeResponseValue;
25827 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
25829 export function derive_public_key(per_commitment_point: number, base_point: number): number {
25830 if(!isWasmInitialized) {
25831 throw new Error("initializeWasm() must be awaited first!");
25833 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
25834 return nativeResponseValue;
25836 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
25838 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
25839 if(!isWasmInitialized) {
25840 throw new Error("initializeWasm() must be awaited first!");
25842 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
25843 return nativeResponseValue;
25845 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
25847 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
25848 if(!isWasmInitialized) {
25849 throw new Error("initializeWasm() must be awaited first!");
25851 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
25852 return nativeResponseValue;
25854 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
25856 export function TxCreationKeys_free(this_obj: number): void {
25857 if(!isWasmInitialized) {
25858 throw new Error("initializeWasm() must be awaited first!");
25860 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
25861 // debug statements here
25863 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25865 export function TxCreationKeys_get_per_commitment_point(this_ptr: number): number {
25866 if(!isWasmInitialized) {
25867 throw new Error("initializeWasm() must be awaited first!");
25869 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
25870 return nativeResponseValue;
25872 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25874 export function TxCreationKeys_set_per_commitment_point(this_ptr: number, val: number): void {
25875 if(!isWasmInitialized) {
25876 throw new Error("initializeWasm() must be awaited first!");
25878 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
25879 // debug statements here
25881 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25883 export function TxCreationKeys_get_revocation_key(this_ptr: number): number {
25884 if(!isWasmInitialized) {
25885 throw new Error("initializeWasm() must be awaited first!");
25887 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
25888 return nativeResponseValue;
25890 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25892 export function TxCreationKeys_set_revocation_key(this_ptr: number, val: number): void {
25893 if(!isWasmInitialized) {
25894 throw new Error("initializeWasm() must be awaited first!");
25896 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
25897 // debug statements here
25899 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25901 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: number): number {
25902 if(!isWasmInitialized) {
25903 throw new Error("initializeWasm() must be awaited first!");
25905 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
25906 return nativeResponseValue;
25908 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25910 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: number, val: number): void {
25911 if(!isWasmInitialized) {
25912 throw new Error("initializeWasm() must be awaited first!");
25914 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
25915 // debug statements here
25917 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25919 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: number): number {
25920 if(!isWasmInitialized) {
25921 throw new Error("initializeWasm() must be awaited first!");
25923 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
25924 return nativeResponseValue;
25926 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25928 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: number, val: number): void {
25929 if(!isWasmInitialized) {
25930 throw new Error("initializeWasm() must be awaited first!");
25932 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
25933 // debug statements here
25935 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25937 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: number): number {
25938 if(!isWasmInitialized) {
25939 throw new Error("initializeWasm() must be awaited first!");
25941 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
25942 return nativeResponseValue;
25944 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25946 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: number, val: number): void {
25947 if(!isWasmInitialized) {
25948 throw new Error("initializeWasm() must be awaited first!");
25950 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
25951 // debug statements here
25953 // 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);
25955 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 {
25956 if(!isWasmInitialized) {
25957 throw new Error("initializeWasm() must be awaited first!");
25959 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);
25960 return nativeResponseValue;
25962 // uintptr_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
25964 export function TxCreationKeys_clone_ptr(arg: number): number {
25965 if(!isWasmInitialized) {
25966 throw new Error("initializeWasm() must be awaited first!");
25968 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
25969 return nativeResponseValue;
25971 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
25973 export function TxCreationKeys_clone(orig: number): number {
25974 if(!isWasmInitialized) {
25975 throw new Error("initializeWasm() must be awaited first!");
25977 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
25978 return nativeResponseValue;
25980 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
25982 export function TxCreationKeys_write(obj: number): number {
25983 if(!isWasmInitialized) {
25984 throw new Error("initializeWasm() must be awaited first!");
25986 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
25987 return nativeResponseValue;
25989 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
25991 export function TxCreationKeys_read(ser: number): number {
25992 if(!isWasmInitialized) {
25993 throw new Error("initializeWasm() must be awaited first!");
25995 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
25996 return nativeResponseValue;
25998 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
26000 export function ChannelPublicKeys_free(this_obj: number): void {
26001 if(!isWasmInitialized) {
26002 throw new Error("initializeWasm() must be awaited first!");
26004 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
26005 // debug statements here
26007 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26009 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: number): number {
26010 if(!isWasmInitialized) {
26011 throw new Error("initializeWasm() must be awaited first!");
26013 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
26014 return nativeResponseValue;
26016 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26018 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: number, val: number): void {
26019 if(!isWasmInitialized) {
26020 throw new Error("initializeWasm() must be awaited first!");
26022 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
26023 // debug statements here
26025 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26027 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: number): number {
26028 if(!isWasmInitialized) {
26029 throw new Error("initializeWasm() must be awaited first!");
26031 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
26032 return nativeResponseValue;
26034 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26036 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: number, val: number): void {
26037 if(!isWasmInitialized) {
26038 throw new Error("initializeWasm() must be awaited first!");
26040 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
26041 // debug statements here
26043 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26045 export function ChannelPublicKeys_get_payment_point(this_ptr: number): number {
26046 if(!isWasmInitialized) {
26047 throw new Error("initializeWasm() must be awaited first!");
26049 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
26050 return nativeResponseValue;
26052 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26054 export function ChannelPublicKeys_set_payment_point(this_ptr: number, val: number): void {
26055 if(!isWasmInitialized) {
26056 throw new Error("initializeWasm() must be awaited first!");
26058 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
26059 // debug statements here
26061 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26063 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: number): number {
26064 if(!isWasmInitialized) {
26065 throw new Error("initializeWasm() must be awaited first!");
26067 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
26068 return nativeResponseValue;
26070 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26072 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
26073 if(!isWasmInitialized) {
26074 throw new Error("initializeWasm() must be awaited first!");
26076 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
26077 // debug statements here
26079 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
26081 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: number): number {
26082 if(!isWasmInitialized) {
26083 throw new Error("initializeWasm() must be awaited first!");
26085 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
26086 return nativeResponseValue;
26088 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
26090 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: number, val: number): void {
26091 if(!isWasmInitialized) {
26092 throw new Error("initializeWasm() must be awaited first!");
26094 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
26095 // debug statements here
26097 // 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);
26099 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 {
26100 if(!isWasmInitialized) {
26101 throw new Error("initializeWasm() must be awaited first!");
26103 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
26104 return nativeResponseValue;
26106 // uintptr_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
26108 export function ChannelPublicKeys_clone_ptr(arg: number): number {
26109 if(!isWasmInitialized) {
26110 throw new Error("initializeWasm() must be awaited first!");
26112 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
26113 return nativeResponseValue;
26115 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
26117 export function ChannelPublicKeys_clone(orig: number): number {
26118 if(!isWasmInitialized) {
26119 throw new Error("initializeWasm() must be awaited first!");
26121 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
26122 return nativeResponseValue;
26124 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
26126 export function ChannelPublicKeys_write(obj: number): number {
26127 if(!isWasmInitialized) {
26128 throw new Error("initializeWasm() must be awaited first!");
26130 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
26131 return nativeResponseValue;
26133 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
26135 export function ChannelPublicKeys_read(ser: number): number {
26136 if(!isWasmInitialized) {
26137 throw new Error("initializeWasm() must be awaited first!");
26139 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
26140 return nativeResponseValue;
26142 // 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);
26144 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 {
26145 if(!isWasmInitialized) {
26146 throw new Error("initializeWasm() must be awaited first!");
26148 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
26149 return nativeResponseValue;
26151 // 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);
26153 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: number, countersignatory_keys: number): number {
26154 if(!isWasmInitialized) {
26155 throw new Error("initializeWasm() must be awaited first!");
26157 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
26158 return nativeResponseValue;
26160 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
26162 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
26163 if(!isWasmInitialized) {
26164 throw new Error("initializeWasm() must be awaited first!");
26166 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
26167 return nativeResponseValue;
26169 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
26171 export function HTLCOutputInCommitment_free(this_obj: number): void {
26172 if(!isWasmInitialized) {
26173 throw new Error("initializeWasm() must be awaited first!");
26175 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
26176 // debug statements here
26178 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
26180 export function HTLCOutputInCommitment_get_offered(this_ptr: number): boolean {
26181 if(!isWasmInitialized) {
26182 throw new Error("initializeWasm() must be awaited first!");
26184 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
26185 return nativeResponseValue;
26187 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
26189 export function HTLCOutputInCommitment_set_offered(this_ptr: number, val: boolean): void {
26190 if(!isWasmInitialized) {
26191 throw new Error("initializeWasm() must be awaited first!");
26193 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
26194 // debug statements here
26196 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
26198 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: number): bigint {
26199 if(!isWasmInitialized) {
26200 throw new Error("initializeWasm() must be awaited first!");
26202 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
26203 return nativeResponseValue;
26205 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
26207 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: number, val: bigint): void {
26208 if(!isWasmInitialized) {
26209 throw new Error("initializeWasm() must be awaited first!");
26211 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
26212 // debug statements here
26214 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
26216 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: number): number {
26217 if(!isWasmInitialized) {
26218 throw new Error("initializeWasm() must be awaited first!");
26220 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
26221 return nativeResponseValue;
26223 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
26225 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: number, val: number): void {
26226 if(!isWasmInitialized) {
26227 throw new Error("initializeWasm() must be awaited first!");
26229 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
26230 // debug statements here
26232 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
26234 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: number): number {
26235 if(!isWasmInitialized) {
26236 throw new Error("initializeWasm() must be awaited first!");
26238 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
26239 return nativeResponseValue;
26241 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26243 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: number, val: number): void {
26244 if(!isWasmInitialized) {
26245 throw new Error("initializeWasm() must be awaited first!");
26247 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
26248 // debug statements here
26250 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
26252 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
26253 if(!isWasmInitialized) {
26254 throw new Error("initializeWasm() must be awaited first!");
26256 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
26257 return nativeResponseValue;
26259 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
26261 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: number, val: number): void {
26262 if(!isWasmInitialized) {
26263 throw new Error("initializeWasm() must be awaited first!");
26265 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
26266 // debug statements here
26268 // 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);
26270 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 {
26271 if(!isWasmInitialized) {
26272 throw new Error("initializeWasm() must be awaited first!");
26274 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
26275 return nativeResponseValue;
26277 // uintptr_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
26279 export function HTLCOutputInCommitment_clone_ptr(arg: number): number {
26280 if(!isWasmInitialized) {
26281 throw new Error("initializeWasm() must be awaited first!");
26283 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
26284 return nativeResponseValue;
26286 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
26288 export function HTLCOutputInCommitment_clone(orig: number): number {
26289 if(!isWasmInitialized) {
26290 throw new Error("initializeWasm() must be awaited first!");
26292 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
26293 return nativeResponseValue;
26295 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
26297 export function HTLCOutputInCommitment_write(obj: number): number {
26298 if(!isWasmInitialized) {
26299 throw new Error("initializeWasm() must be awaited first!");
26301 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
26302 return nativeResponseValue;
26304 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
26306 export function HTLCOutputInCommitment_read(ser: number): number {
26307 if(!isWasmInitialized) {
26308 throw new Error("initializeWasm() must be awaited first!");
26310 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
26311 return nativeResponseValue;
26313 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
26315 export function get_htlc_redeemscript(htlc: number, opt_anchors: boolean, keys: number): number {
26316 if(!isWasmInitialized) {
26317 throw new Error("initializeWasm() must be awaited first!");
26319 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
26320 return nativeResponseValue;
26322 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
26324 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
26325 if(!isWasmInitialized) {
26326 throw new Error("initializeWasm() must be awaited first!");
26328 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
26329 return nativeResponseValue;
26331 // 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);
26333 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 {
26334 if(!isWasmInitialized) {
26335 throw new Error("initializeWasm() must be awaited first!");
26337 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
26338 return nativeResponseValue;
26340 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
26342 export function get_anchor_redeemscript(funding_pubkey: number): number {
26343 if(!isWasmInitialized) {
26344 throw new Error("initializeWasm() must be awaited first!");
26346 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
26347 return nativeResponseValue;
26349 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
26351 export function ChannelTransactionParameters_free(this_obj: number): void {
26352 if(!isWasmInitialized) {
26353 throw new Error("initializeWasm() must be awaited first!");
26355 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
26356 // debug statements here
26358 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26360 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: number): number {
26361 if(!isWasmInitialized) {
26362 throw new Error("initializeWasm() must be awaited first!");
26364 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
26365 return nativeResponseValue;
26367 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
26369 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: number, val: number): void {
26370 if(!isWasmInitialized) {
26371 throw new Error("initializeWasm() must be awaited first!");
26373 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
26374 // debug statements here
26376 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26378 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: number): number {
26379 if(!isWasmInitialized) {
26380 throw new Error("initializeWasm() must be awaited first!");
26382 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
26383 return nativeResponseValue;
26385 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
26387 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: number, val: number): void {
26388 if(!isWasmInitialized) {
26389 throw new Error("initializeWasm() must be awaited first!");
26391 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
26392 // debug statements here
26394 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26396 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: number): boolean {
26397 if(!isWasmInitialized) {
26398 throw new Error("initializeWasm() must be awaited first!");
26400 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
26401 return nativeResponseValue;
26403 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
26405 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: number, val: boolean): void {
26406 if(!isWasmInitialized) {
26407 throw new Error("initializeWasm() must be awaited first!");
26409 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
26410 // debug statements here
26412 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26414 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: number): number {
26415 if(!isWasmInitialized) {
26416 throw new Error("initializeWasm() must be awaited first!");
26418 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
26419 return nativeResponseValue;
26421 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
26423 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: number, val: number): void {
26424 if(!isWasmInitialized) {
26425 throw new Error("initializeWasm() must be awaited first!");
26427 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
26428 // debug statements here
26430 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26432 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: number): number {
26433 if(!isWasmInitialized) {
26434 throw new Error("initializeWasm() must be awaited first!");
26436 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
26437 return nativeResponseValue;
26439 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
26441 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: number, val: number): void {
26442 if(!isWasmInitialized) {
26443 throw new Error("initializeWasm() must be awaited first!");
26445 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
26446 // debug statements here
26448 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
26450 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: number): COption_NoneZ {
26451 if(!isWasmInitialized) {
26452 throw new Error("initializeWasm() must be awaited first!");
26454 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
26455 return nativeResponseValue;
26457 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
26459 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: number, val: COption_NoneZ): void {
26460 if(!isWasmInitialized) {
26461 throw new Error("initializeWasm() must be awaited first!");
26463 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
26464 // debug statements here
26466 // 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);
26468 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 {
26469 if(!isWasmInitialized) {
26470 throw new Error("initializeWasm() must be awaited first!");
26472 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);
26473 return nativeResponseValue;
26475 // uintptr_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
26477 export function ChannelTransactionParameters_clone_ptr(arg: number): number {
26478 if(!isWasmInitialized) {
26479 throw new Error("initializeWasm() must be awaited first!");
26481 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
26482 return nativeResponseValue;
26484 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
26486 export function ChannelTransactionParameters_clone(orig: number): number {
26487 if(!isWasmInitialized) {
26488 throw new Error("initializeWasm() must be awaited first!");
26490 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
26491 return nativeResponseValue;
26493 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
26495 export function CounterpartyChannelTransactionParameters_free(this_obj: number): void {
26496 if(!isWasmInitialized) {
26497 throw new Error("initializeWasm() must be awaited first!");
26499 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
26500 // debug statements here
26502 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
26504 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: number): number {
26505 if(!isWasmInitialized) {
26506 throw new Error("initializeWasm() must be awaited first!");
26508 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
26509 return nativeResponseValue;
26511 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
26513 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: number, val: number): void {
26514 if(!isWasmInitialized) {
26515 throw new Error("initializeWasm() must be awaited first!");
26517 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
26518 // debug statements here
26520 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
26522 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: number): number {
26523 if(!isWasmInitialized) {
26524 throw new Error("initializeWasm() must be awaited first!");
26526 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
26527 return nativeResponseValue;
26529 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
26531 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: number, val: number): void {
26532 if(!isWasmInitialized) {
26533 throw new Error("initializeWasm() must be awaited first!");
26535 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
26536 // debug statements here
26538 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
26540 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: number, selected_contest_delay_arg: number): number {
26541 if(!isWasmInitialized) {
26542 throw new Error("initializeWasm() must be awaited first!");
26544 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
26545 return nativeResponseValue;
26547 // uintptr_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
26549 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: number): number {
26550 if(!isWasmInitialized) {
26551 throw new Error("initializeWasm() must be awaited first!");
26553 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
26554 return nativeResponseValue;
26556 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
26558 export function CounterpartyChannelTransactionParameters_clone(orig: number): number {
26559 if(!isWasmInitialized) {
26560 throw new Error("initializeWasm() must be awaited first!");
26562 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
26563 return nativeResponseValue;
26565 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26567 export function ChannelTransactionParameters_is_populated(this_arg: number): boolean {
26568 if(!isWasmInitialized) {
26569 throw new Error("initializeWasm() must be awaited first!");
26571 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
26572 return nativeResponseValue;
26574 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26576 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: number): number {
26577 if(!isWasmInitialized) {
26578 throw new Error("initializeWasm() must be awaited first!");
26580 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
26581 return nativeResponseValue;
26583 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26585 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: number): number {
26586 if(!isWasmInitialized) {
26587 throw new Error("initializeWasm() must be awaited first!");
26589 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
26590 return nativeResponseValue;
26592 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
26594 export function CounterpartyChannelTransactionParameters_write(obj: number): number {
26595 if(!isWasmInitialized) {
26596 throw new Error("initializeWasm() must be awaited first!");
26598 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
26599 return nativeResponseValue;
26601 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
26603 export function CounterpartyChannelTransactionParameters_read(ser: number): number {
26604 if(!isWasmInitialized) {
26605 throw new Error("initializeWasm() must be awaited first!");
26607 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
26608 return nativeResponseValue;
26610 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
26612 export function ChannelTransactionParameters_write(obj: number): number {
26613 if(!isWasmInitialized) {
26614 throw new Error("initializeWasm() must be awaited first!");
26616 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
26617 return nativeResponseValue;
26619 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
26621 export function ChannelTransactionParameters_read(ser: number): number {
26622 if(!isWasmInitialized) {
26623 throw new Error("initializeWasm() must be awaited first!");
26625 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
26626 return nativeResponseValue;
26628 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
26630 export function DirectedChannelTransactionParameters_free(this_obj: number): void {
26631 if(!isWasmInitialized) {
26632 throw new Error("initializeWasm() must be awaited first!");
26634 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
26635 // debug statements here
26637 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26639 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: number): number {
26640 if(!isWasmInitialized) {
26641 throw new Error("initializeWasm() must be awaited first!");
26643 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
26644 return nativeResponseValue;
26646 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26648 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: number): number {
26649 if(!isWasmInitialized) {
26650 throw new Error("initializeWasm() must be awaited first!");
26652 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
26653 return nativeResponseValue;
26655 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26657 export function DirectedChannelTransactionParameters_contest_delay(this_arg: number): number {
26658 if(!isWasmInitialized) {
26659 throw new Error("initializeWasm() must be awaited first!");
26661 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
26662 return nativeResponseValue;
26664 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26666 export function DirectedChannelTransactionParameters_is_outbound(this_arg: number): boolean {
26667 if(!isWasmInitialized) {
26668 throw new Error("initializeWasm() must be awaited first!");
26670 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
26671 return nativeResponseValue;
26673 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26675 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: number): number {
26676 if(!isWasmInitialized) {
26677 throw new Error("initializeWasm() must be awaited first!");
26679 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
26680 return nativeResponseValue;
26682 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26684 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: number): boolean {
26685 if(!isWasmInitialized) {
26686 throw new Error("initializeWasm() must be awaited first!");
26688 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
26689 return nativeResponseValue;
26691 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
26693 export function HolderCommitmentTransaction_free(this_obj: number): void {
26694 if(!isWasmInitialized) {
26695 throw new Error("initializeWasm() must be awaited first!");
26697 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
26698 // debug statements here
26700 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
26702 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: number): number {
26703 if(!isWasmInitialized) {
26704 throw new Error("initializeWasm() must be awaited first!");
26706 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
26707 return nativeResponseValue;
26709 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
26711 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: number, val: number): void {
26712 if(!isWasmInitialized) {
26713 throw new Error("initializeWasm() must be awaited first!");
26715 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
26716 // debug statements here
26718 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
26720 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: number, val: number): void {
26721 if(!isWasmInitialized) {
26722 throw new Error("initializeWasm() must be awaited first!");
26724 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
26725 // debug statements here
26727 // uintptr_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
26729 export function HolderCommitmentTransaction_clone_ptr(arg: number): number {
26730 if(!isWasmInitialized) {
26731 throw new Error("initializeWasm() must be awaited first!");
26733 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
26734 return nativeResponseValue;
26736 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
26738 export function HolderCommitmentTransaction_clone(orig: number): number {
26739 if(!isWasmInitialized) {
26740 throw new Error("initializeWasm() must be awaited first!");
26742 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
26743 return nativeResponseValue;
26745 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
26747 export function HolderCommitmentTransaction_write(obj: number): number {
26748 if(!isWasmInitialized) {
26749 throw new Error("initializeWasm() must be awaited first!");
26751 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
26752 return nativeResponseValue;
26754 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
26756 export function HolderCommitmentTransaction_read(ser: number): number {
26757 if(!isWasmInitialized) {
26758 throw new Error("initializeWasm() must be awaited first!");
26760 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
26761 return nativeResponseValue;
26763 // 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);
26765 export function HolderCommitmentTransaction_new(commitment_tx: number, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): number {
26766 if(!isWasmInitialized) {
26767 throw new Error("initializeWasm() must be awaited first!");
26769 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
26770 return nativeResponseValue;
26772 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
26774 export function BuiltCommitmentTransaction_free(this_obj: number): void {
26775 if(!isWasmInitialized) {
26776 throw new Error("initializeWasm() must be awaited first!");
26778 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
26779 // debug statements here
26781 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
26783 export function BuiltCommitmentTransaction_get_transaction(this_ptr: number): number {
26784 if(!isWasmInitialized) {
26785 throw new Error("initializeWasm() must be awaited first!");
26787 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
26788 return nativeResponseValue;
26790 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
26792 export function BuiltCommitmentTransaction_set_transaction(this_ptr: number, val: number): void {
26793 if(!isWasmInitialized) {
26794 throw new Error("initializeWasm() must be awaited first!");
26796 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
26797 // debug statements here
26799 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
26801 export function BuiltCommitmentTransaction_get_txid(this_ptr: number): number {
26802 if(!isWasmInitialized) {
26803 throw new Error("initializeWasm() must be awaited first!");
26805 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
26806 return nativeResponseValue;
26808 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26810 export function BuiltCommitmentTransaction_set_txid(this_ptr: number, val: number): void {
26811 if(!isWasmInitialized) {
26812 throw new Error("initializeWasm() must be awaited first!");
26814 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
26815 // debug statements here
26817 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
26819 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): number {
26820 if(!isWasmInitialized) {
26821 throw new Error("initializeWasm() must be awaited first!");
26823 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
26824 return nativeResponseValue;
26826 // uintptr_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
26828 export function BuiltCommitmentTransaction_clone_ptr(arg: number): number {
26829 if(!isWasmInitialized) {
26830 throw new Error("initializeWasm() must be awaited first!");
26832 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
26833 return nativeResponseValue;
26835 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
26837 export function BuiltCommitmentTransaction_clone(orig: number): number {
26838 if(!isWasmInitialized) {
26839 throw new Error("initializeWasm() must be awaited first!");
26841 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
26842 return nativeResponseValue;
26844 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
26846 export function BuiltCommitmentTransaction_write(obj: number): number {
26847 if(!isWasmInitialized) {
26848 throw new Error("initializeWasm() must be awaited first!");
26850 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
26851 return nativeResponseValue;
26853 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
26855 export function BuiltCommitmentTransaction_read(ser: number): number {
26856 if(!isWasmInitialized) {
26857 throw new Error("initializeWasm() must be awaited first!");
26859 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
26860 return nativeResponseValue;
26862 // 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);
26864 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26865 if(!isWasmInitialized) {
26866 throw new Error("initializeWasm() must be awaited first!");
26868 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
26869 return nativeResponseValue;
26871 // 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);
26873 export function BuiltCommitmentTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26874 if(!isWasmInitialized) {
26875 throw new Error("initializeWasm() must be awaited first!");
26877 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
26878 return nativeResponseValue;
26880 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
26882 export function ClosingTransaction_free(this_obj: number): void {
26883 if(!isWasmInitialized) {
26884 throw new Error("initializeWasm() must be awaited first!");
26886 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
26887 // debug statements here
26889 // uintptr_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
26891 export function ClosingTransaction_clone_ptr(arg: number): number {
26892 if(!isWasmInitialized) {
26893 throw new Error("initializeWasm() must be awaited first!");
26895 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
26896 return nativeResponseValue;
26898 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
26900 export function ClosingTransaction_clone(orig: number): number {
26901 if(!isWasmInitialized) {
26902 throw new Error("initializeWasm() must be awaited first!");
26904 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
26905 return nativeResponseValue;
26907 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
26909 export function ClosingTransaction_hash(o: number): bigint {
26910 if(!isWasmInitialized) {
26911 throw new Error("initializeWasm() must be awaited first!");
26913 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
26914 return nativeResponseValue;
26916 // 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);
26918 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 {
26919 if(!isWasmInitialized) {
26920 throw new Error("initializeWasm() must be awaited first!");
26922 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
26923 return nativeResponseValue;
26925 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26927 export function ClosingTransaction_trust(this_arg: number): number {
26928 if(!isWasmInitialized) {
26929 throw new Error("initializeWasm() must be awaited first!");
26931 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
26932 return nativeResponseValue;
26934 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
26936 export function ClosingTransaction_verify(this_arg: number, funding_outpoint: number): number {
26937 if(!isWasmInitialized) {
26938 throw new Error("initializeWasm() must be awaited first!");
26940 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
26941 return nativeResponseValue;
26943 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26945 export function ClosingTransaction_to_holder_value_sat(this_arg: number): bigint {
26946 if(!isWasmInitialized) {
26947 throw new Error("initializeWasm() must be awaited first!");
26949 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
26950 return nativeResponseValue;
26952 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26954 export function ClosingTransaction_to_counterparty_value_sat(this_arg: number): bigint {
26955 if(!isWasmInitialized) {
26956 throw new Error("initializeWasm() must be awaited first!");
26958 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
26959 return nativeResponseValue;
26961 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26963 export function ClosingTransaction_to_holder_script(this_arg: number): number {
26964 if(!isWasmInitialized) {
26965 throw new Error("initializeWasm() must be awaited first!");
26967 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
26968 return nativeResponseValue;
26970 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26972 export function ClosingTransaction_to_counterparty_script(this_arg: number): number {
26973 if(!isWasmInitialized) {
26974 throw new Error("initializeWasm() must be awaited first!");
26976 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
26977 return nativeResponseValue;
26979 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
26981 export function TrustedClosingTransaction_free(this_obj: number): void {
26982 if(!isWasmInitialized) {
26983 throw new Error("initializeWasm() must be awaited first!");
26985 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
26986 // debug statements here
26988 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
26990 export function TrustedClosingTransaction_built_transaction(this_arg: number): number {
26991 if(!isWasmInitialized) {
26992 throw new Error("initializeWasm() must be awaited first!");
26994 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
26995 return nativeResponseValue;
26997 // 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);
26999 export function TrustedClosingTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
27000 if(!isWasmInitialized) {
27001 throw new Error("initializeWasm() must be awaited first!");
27003 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
27004 return nativeResponseValue;
27006 // 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);
27008 export function TrustedClosingTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
27009 if(!isWasmInitialized) {
27010 throw new Error("initializeWasm() must be awaited first!");
27012 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
27013 return nativeResponseValue;
27015 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
27017 export function CommitmentTransaction_free(this_obj: number): void {
27018 if(!isWasmInitialized) {
27019 throw new Error("initializeWasm() must be awaited first!");
27021 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
27022 // debug statements here
27024 // uintptr_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
27026 export function CommitmentTransaction_clone_ptr(arg: number): number {
27027 if(!isWasmInitialized) {
27028 throw new Error("initializeWasm() must be awaited first!");
27030 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
27031 return nativeResponseValue;
27033 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
27035 export function CommitmentTransaction_clone(orig: number): number {
27036 if(!isWasmInitialized) {
27037 throw new Error("initializeWasm() must be awaited first!");
27039 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
27040 return nativeResponseValue;
27042 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
27044 export function CommitmentTransaction_write(obj: number): number {
27045 if(!isWasmInitialized) {
27046 throw new Error("initializeWasm() must be awaited first!");
27048 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
27049 return nativeResponseValue;
27051 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
27053 export function CommitmentTransaction_read(ser: number): number {
27054 if(!isWasmInitialized) {
27055 throw new Error("initializeWasm() must be awaited first!");
27057 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
27058 return nativeResponseValue;
27060 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27062 export function CommitmentTransaction_commitment_number(this_arg: number): bigint {
27063 if(!isWasmInitialized) {
27064 throw new Error("initializeWasm() must be awaited first!");
27066 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
27067 return nativeResponseValue;
27069 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27071 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: number): bigint {
27072 if(!isWasmInitialized) {
27073 throw new Error("initializeWasm() must be awaited first!");
27075 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
27076 return nativeResponseValue;
27078 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27080 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: number): bigint {
27081 if(!isWasmInitialized) {
27082 throw new Error("initializeWasm() must be awaited first!");
27084 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
27085 return nativeResponseValue;
27087 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27089 export function CommitmentTransaction_feerate_per_kw(this_arg: number): number {
27090 if(!isWasmInitialized) {
27091 throw new Error("initializeWasm() must be awaited first!");
27093 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
27094 return nativeResponseValue;
27096 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
27098 export function CommitmentTransaction_trust(this_arg: number): number {
27099 if(!isWasmInitialized) {
27100 throw new Error("initializeWasm() must be awaited first!");
27102 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
27103 return nativeResponseValue;
27105 // 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);
27107 export function CommitmentTransaction_verify(this_arg: number, channel_parameters: number, broadcaster_keys: number, countersignatory_keys: number): number {
27108 if(!isWasmInitialized) {
27109 throw new Error("initializeWasm() must be awaited first!");
27111 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
27112 return nativeResponseValue;
27114 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
27116 export function TrustedCommitmentTransaction_free(this_obj: number): void {
27117 if(!isWasmInitialized) {
27118 throw new Error("initializeWasm() must be awaited first!");
27120 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
27121 // debug statements here
27123 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
27125 export function TrustedCommitmentTransaction_txid(this_arg: number): number {
27126 if(!isWasmInitialized) {
27127 throw new Error("initializeWasm() must be awaited first!");
27129 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
27130 return nativeResponseValue;
27132 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
27134 export function TrustedCommitmentTransaction_built_transaction(this_arg: number): number {
27135 if(!isWasmInitialized) {
27136 throw new Error("initializeWasm() must be awaited first!");
27138 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
27139 return nativeResponseValue;
27141 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
27143 export function TrustedCommitmentTransaction_keys(this_arg: number): number {
27144 if(!isWasmInitialized) {
27145 throw new Error("initializeWasm() must be awaited first!");
27147 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
27148 return nativeResponseValue;
27150 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
27152 export function TrustedCommitmentTransaction_opt_anchors(this_arg: number): boolean {
27153 if(!isWasmInitialized) {
27154 throw new Error("initializeWasm() must be awaited first!");
27156 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
27157 return nativeResponseValue;
27159 // 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);
27161 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: number, htlc_base_key: number, channel_parameters: number): number {
27162 if(!isWasmInitialized) {
27163 throw new Error("initializeWasm() must be awaited first!");
27165 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
27166 return nativeResponseValue;
27168 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
27170 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
27171 if(!isWasmInitialized) {
27172 throw new Error("initializeWasm() must be awaited first!");
27174 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
27175 return nativeResponseValue;
27177 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
27179 export function InitFeatures_eq(a: number, b: number): boolean {
27180 if(!isWasmInitialized) {
27181 throw new Error("initializeWasm() must be awaited first!");
27183 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
27184 return nativeResponseValue;
27186 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
27188 export function NodeFeatures_eq(a: number, b: number): boolean {
27189 if(!isWasmInitialized) {
27190 throw new Error("initializeWasm() must be awaited first!");
27192 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
27193 return nativeResponseValue;
27195 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
27197 export function ChannelFeatures_eq(a: number, b: number): boolean {
27198 if(!isWasmInitialized) {
27199 throw new Error("initializeWasm() must be awaited first!");
27201 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
27202 return nativeResponseValue;
27204 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
27206 export function InvoiceFeatures_eq(a: number, b: number): boolean {
27207 if(!isWasmInitialized) {
27208 throw new Error("initializeWasm() must be awaited first!");
27210 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
27211 return nativeResponseValue;
27213 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
27215 export function ChannelTypeFeatures_eq(a: number, b: number): boolean {
27216 if(!isWasmInitialized) {
27217 throw new Error("initializeWasm() must be awaited first!");
27219 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
27220 return nativeResponseValue;
27222 // uintptr_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
27224 export function InitFeatures_clone_ptr(arg: number): number {
27225 if(!isWasmInitialized) {
27226 throw new Error("initializeWasm() must be awaited first!");
27228 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
27229 return nativeResponseValue;
27231 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
27233 export function InitFeatures_clone(orig: number): number {
27234 if(!isWasmInitialized) {
27235 throw new Error("initializeWasm() must be awaited first!");
27237 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
27238 return nativeResponseValue;
27240 // uintptr_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
27242 export function NodeFeatures_clone_ptr(arg: number): number {
27243 if(!isWasmInitialized) {
27244 throw new Error("initializeWasm() must be awaited first!");
27246 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
27247 return nativeResponseValue;
27249 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
27251 export function NodeFeatures_clone(orig: number): number {
27252 if(!isWasmInitialized) {
27253 throw new Error("initializeWasm() must be awaited first!");
27255 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
27256 return nativeResponseValue;
27258 // uintptr_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
27260 export function ChannelFeatures_clone_ptr(arg: number): number {
27261 if(!isWasmInitialized) {
27262 throw new Error("initializeWasm() must be awaited first!");
27264 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
27265 return nativeResponseValue;
27267 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
27269 export function ChannelFeatures_clone(orig: number): number {
27270 if(!isWasmInitialized) {
27271 throw new Error("initializeWasm() must be awaited first!");
27273 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
27274 return nativeResponseValue;
27276 // uintptr_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
27278 export function InvoiceFeatures_clone_ptr(arg: number): number {
27279 if(!isWasmInitialized) {
27280 throw new Error("initializeWasm() must be awaited first!");
27282 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
27283 return nativeResponseValue;
27285 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
27287 export function InvoiceFeatures_clone(orig: number): number {
27288 if(!isWasmInitialized) {
27289 throw new Error("initializeWasm() must be awaited first!");
27291 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
27292 return nativeResponseValue;
27294 // uintptr_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
27296 export function ChannelTypeFeatures_clone_ptr(arg: number): number {
27297 if(!isWasmInitialized) {
27298 throw new Error("initializeWasm() must be awaited first!");
27300 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
27301 return nativeResponseValue;
27303 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
27305 export function ChannelTypeFeatures_clone(orig: number): number {
27306 if(!isWasmInitialized) {
27307 throw new Error("initializeWasm() must be awaited first!");
27309 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
27310 return nativeResponseValue;
27312 // void InitFeatures_free(struct LDKInitFeatures this_obj);
27314 export function InitFeatures_free(this_obj: number): void {
27315 if(!isWasmInitialized) {
27316 throw new Error("initializeWasm() must be awaited first!");
27318 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
27319 // debug statements here
27321 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
27323 export function NodeFeatures_free(this_obj: number): void {
27324 if(!isWasmInitialized) {
27325 throw new Error("initializeWasm() must be awaited first!");
27327 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
27328 // debug statements here
27330 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
27332 export function ChannelFeatures_free(this_obj: number): void {
27333 if(!isWasmInitialized) {
27334 throw new Error("initializeWasm() must be awaited first!");
27336 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
27337 // debug statements here
27339 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
27341 export function InvoiceFeatures_free(this_obj: number): void {
27342 if(!isWasmInitialized) {
27343 throw new Error("initializeWasm() must be awaited first!");
27345 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
27346 // debug statements here
27348 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
27350 export function ChannelTypeFeatures_free(this_obj: number): void {
27351 if(!isWasmInitialized) {
27352 throw new Error("initializeWasm() must be awaited first!");
27354 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
27355 // debug statements here
27357 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
27359 export function InitFeatures_empty(): number {
27360 if(!isWasmInitialized) {
27361 throw new Error("initializeWasm() must be awaited first!");
27363 const nativeResponseValue = wasm.TS_InitFeatures_empty();
27364 return nativeResponseValue;
27366 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
27368 export function InitFeatures_known(): number {
27369 if(!isWasmInitialized) {
27370 throw new Error("initializeWasm() must be awaited first!");
27372 const nativeResponseValue = wasm.TS_InitFeatures_known();
27373 return nativeResponseValue;
27375 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27377 export function InitFeatures_requires_unknown_bits(this_arg: number): boolean {
27378 if(!isWasmInitialized) {
27379 throw new Error("initializeWasm() must be awaited first!");
27381 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
27382 return nativeResponseValue;
27384 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
27386 export function NodeFeatures_empty(): number {
27387 if(!isWasmInitialized) {
27388 throw new Error("initializeWasm() must be awaited first!");
27390 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
27391 return nativeResponseValue;
27393 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
27395 export function NodeFeatures_known(): number {
27396 if(!isWasmInitialized) {
27397 throw new Error("initializeWasm() must be awaited first!");
27399 const nativeResponseValue = wasm.TS_NodeFeatures_known();
27400 return nativeResponseValue;
27402 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27404 export function NodeFeatures_requires_unknown_bits(this_arg: number): boolean {
27405 if(!isWasmInitialized) {
27406 throw new Error("initializeWasm() must be awaited first!");
27408 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
27409 return nativeResponseValue;
27411 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
27413 export function ChannelFeatures_empty(): number {
27414 if(!isWasmInitialized) {
27415 throw new Error("initializeWasm() must be awaited first!");
27417 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
27418 return nativeResponseValue;
27420 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
27422 export function ChannelFeatures_known(): number {
27423 if(!isWasmInitialized) {
27424 throw new Error("initializeWasm() must be awaited first!");
27426 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
27427 return nativeResponseValue;
27429 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
27431 export function ChannelFeatures_requires_unknown_bits(this_arg: number): boolean {
27432 if(!isWasmInitialized) {
27433 throw new Error("initializeWasm() must be awaited first!");
27435 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
27436 return nativeResponseValue;
27438 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
27440 export function InvoiceFeatures_empty(): number {
27441 if(!isWasmInitialized) {
27442 throw new Error("initializeWasm() must be awaited first!");
27444 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
27445 return nativeResponseValue;
27447 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
27449 export function InvoiceFeatures_known(): number {
27450 if(!isWasmInitialized) {
27451 throw new Error("initializeWasm() must be awaited first!");
27453 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
27454 return nativeResponseValue;
27456 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27458 export function InvoiceFeatures_requires_unknown_bits(this_arg: number): boolean {
27459 if(!isWasmInitialized) {
27460 throw new Error("initializeWasm() must be awaited first!");
27462 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
27463 return nativeResponseValue;
27465 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
27467 export function ChannelTypeFeatures_empty(): number {
27468 if(!isWasmInitialized) {
27469 throw new Error("initializeWasm() must be awaited first!");
27471 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
27472 return nativeResponseValue;
27474 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
27476 export function ChannelTypeFeatures_known(): number {
27477 if(!isWasmInitialized) {
27478 throw new Error("initializeWasm() must be awaited first!");
27480 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
27481 return nativeResponseValue;
27483 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27485 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: number): boolean {
27486 if(!isWasmInitialized) {
27487 throw new Error("initializeWasm() must be awaited first!");
27489 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
27490 return nativeResponseValue;
27492 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
27494 export function InitFeatures_write(obj: number): number {
27495 if(!isWasmInitialized) {
27496 throw new Error("initializeWasm() must be awaited first!");
27498 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
27499 return nativeResponseValue;
27501 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
27503 export function InitFeatures_read(ser: number): number {
27504 if(!isWasmInitialized) {
27505 throw new Error("initializeWasm() must be awaited first!");
27507 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
27508 return nativeResponseValue;
27510 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
27512 export function ChannelFeatures_write(obj: number): number {
27513 if(!isWasmInitialized) {
27514 throw new Error("initializeWasm() must be awaited first!");
27516 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
27517 return nativeResponseValue;
27519 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
27521 export function ChannelFeatures_read(ser: number): number {
27522 if(!isWasmInitialized) {
27523 throw new Error("initializeWasm() must be awaited first!");
27525 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
27526 return nativeResponseValue;
27528 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
27530 export function NodeFeatures_write(obj: number): number {
27531 if(!isWasmInitialized) {
27532 throw new Error("initializeWasm() must be awaited first!");
27534 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
27535 return nativeResponseValue;
27537 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
27539 export function NodeFeatures_read(ser: number): number {
27540 if(!isWasmInitialized) {
27541 throw new Error("initializeWasm() must be awaited first!");
27543 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
27544 return nativeResponseValue;
27546 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
27548 export function InvoiceFeatures_write(obj: number): number {
27549 if(!isWasmInitialized) {
27550 throw new Error("initializeWasm() must be awaited first!");
27552 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
27553 return nativeResponseValue;
27555 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
27557 export function InvoiceFeatures_read(ser: number): number {
27558 if(!isWasmInitialized) {
27559 throw new Error("initializeWasm() must be awaited first!");
27561 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
27562 return nativeResponseValue;
27564 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
27566 export function ChannelTypeFeatures_write(obj: number): number {
27567 if(!isWasmInitialized) {
27568 throw new Error("initializeWasm() must be awaited first!");
27570 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
27571 return nativeResponseValue;
27573 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
27575 export function ChannelTypeFeatures_read(ser: number): number {
27576 if(!isWasmInitialized) {
27577 throw new Error("initializeWasm() must be awaited first!");
27579 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
27580 return nativeResponseValue;
27582 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27584 export function InitFeatures_set_data_loss_protect_optional(this_arg: number): void {
27585 if(!isWasmInitialized) {
27586 throw new Error("initializeWasm() must be awaited first!");
27588 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
27589 // debug statements here
27591 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27593 export function InitFeatures_set_data_loss_protect_required(this_arg: number): void {
27594 if(!isWasmInitialized) {
27595 throw new Error("initializeWasm() must be awaited first!");
27597 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
27598 // debug statements here
27600 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27602 export function InitFeatures_supports_data_loss_protect(this_arg: number): boolean {
27603 if(!isWasmInitialized) {
27604 throw new Error("initializeWasm() must be awaited first!");
27606 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
27607 return nativeResponseValue;
27609 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27611 export function NodeFeatures_set_data_loss_protect_optional(this_arg: number): void {
27612 if(!isWasmInitialized) {
27613 throw new Error("initializeWasm() must be awaited first!");
27615 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
27616 // debug statements here
27618 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27620 export function NodeFeatures_set_data_loss_protect_required(this_arg: number): void {
27621 if(!isWasmInitialized) {
27622 throw new Error("initializeWasm() must be awaited first!");
27624 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
27625 // debug statements here
27627 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27629 export function NodeFeatures_supports_data_loss_protect(this_arg: number): boolean {
27630 if(!isWasmInitialized) {
27631 throw new Error("initializeWasm() must be awaited first!");
27633 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
27634 return nativeResponseValue;
27636 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27638 export function InitFeatures_requires_data_loss_protect(this_arg: number): boolean {
27639 if(!isWasmInitialized) {
27640 throw new Error("initializeWasm() must be awaited first!");
27642 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
27643 return nativeResponseValue;
27645 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27647 export function NodeFeatures_requires_data_loss_protect(this_arg: number): boolean {
27648 if(!isWasmInitialized) {
27649 throw new Error("initializeWasm() must be awaited first!");
27651 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
27652 return nativeResponseValue;
27654 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27656 export function InitFeatures_set_initial_routing_sync_optional(this_arg: number): void {
27657 if(!isWasmInitialized) {
27658 throw new Error("initializeWasm() must be awaited first!");
27660 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
27661 // debug statements here
27663 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27665 export function InitFeatures_set_initial_routing_sync_required(this_arg: number): void {
27666 if(!isWasmInitialized) {
27667 throw new Error("initializeWasm() must be awaited first!");
27669 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
27670 // debug statements here
27672 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27674 export function InitFeatures_initial_routing_sync(this_arg: number): boolean {
27675 if(!isWasmInitialized) {
27676 throw new Error("initializeWasm() must be awaited first!");
27678 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
27679 return nativeResponseValue;
27681 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27683 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: number): void {
27684 if(!isWasmInitialized) {
27685 throw new Error("initializeWasm() must be awaited first!");
27687 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
27688 // debug statements here
27690 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27692 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: number): void {
27693 if(!isWasmInitialized) {
27694 throw new Error("initializeWasm() must be awaited first!");
27696 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
27697 // debug statements here
27699 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27701 export function InitFeatures_supports_upfront_shutdown_script(this_arg: number): boolean {
27702 if(!isWasmInitialized) {
27703 throw new Error("initializeWasm() must be awaited first!");
27705 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
27706 return nativeResponseValue;
27708 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27710 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: number): void {
27711 if(!isWasmInitialized) {
27712 throw new Error("initializeWasm() must be awaited first!");
27714 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
27715 // debug statements here
27717 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27719 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: number): void {
27720 if(!isWasmInitialized) {
27721 throw new Error("initializeWasm() must be awaited first!");
27723 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
27724 // debug statements here
27726 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27728 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: number): boolean {
27729 if(!isWasmInitialized) {
27730 throw new Error("initializeWasm() must be awaited first!");
27732 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
27733 return nativeResponseValue;
27735 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27737 export function InitFeatures_requires_upfront_shutdown_script(this_arg: number): boolean {
27738 if(!isWasmInitialized) {
27739 throw new Error("initializeWasm() must be awaited first!");
27741 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
27742 return nativeResponseValue;
27744 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27746 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: number): boolean {
27747 if(!isWasmInitialized) {
27748 throw new Error("initializeWasm() must be awaited first!");
27750 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
27751 return nativeResponseValue;
27753 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27755 export function InitFeatures_set_gossip_queries_optional(this_arg: number): void {
27756 if(!isWasmInitialized) {
27757 throw new Error("initializeWasm() must be awaited first!");
27759 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
27760 // debug statements here
27762 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27764 export function InitFeatures_set_gossip_queries_required(this_arg: number): void {
27765 if(!isWasmInitialized) {
27766 throw new Error("initializeWasm() must be awaited first!");
27768 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
27769 // debug statements here
27771 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27773 export function InitFeatures_supports_gossip_queries(this_arg: number): boolean {
27774 if(!isWasmInitialized) {
27775 throw new Error("initializeWasm() must be awaited first!");
27777 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
27778 return nativeResponseValue;
27780 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27782 export function NodeFeatures_set_gossip_queries_optional(this_arg: number): void {
27783 if(!isWasmInitialized) {
27784 throw new Error("initializeWasm() must be awaited first!");
27786 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
27787 // debug statements here
27789 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27791 export function NodeFeatures_set_gossip_queries_required(this_arg: number): void {
27792 if(!isWasmInitialized) {
27793 throw new Error("initializeWasm() must be awaited first!");
27795 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
27796 // debug statements here
27798 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27800 export function NodeFeatures_supports_gossip_queries(this_arg: number): boolean {
27801 if(!isWasmInitialized) {
27802 throw new Error("initializeWasm() must be awaited first!");
27804 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
27805 return nativeResponseValue;
27807 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27809 export function InitFeatures_requires_gossip_queries(this_arg: number): boolean {
27810 if(!isWasmInitialized) {
27811 throw new Error("initializeWasm() must be awaited first!");
27813 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
27814 return nativeResponseValue;
27816 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27818 export function NodeFeatures_requires_gossip_queries(this_arg: number): boolean {
27819 if(!isWasmInitialized) {
27820 throw new Error("initializeWasm() must be awaited first!");
27822 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
27823 return nativeResponseValue;
27825 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27827 export function InitFeatures_set_variable_length_onion_optional(this_arg: number): void {
27828 if(!isWasmInitialized) {
27829 throw new Error("initializeWasm() must be awaited first!");
27831 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
27832 // debug statements here
27834 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27836 export function InitFeatures_set_variable_length_onion_required(this_arg: number): void {
27837 if(!isWasmInitialized) {
27838 throw new Error("initializeWasm() must be awaited first!");
27840 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
27841 // debug statements here
27843 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27845 export function InitFeatures_supports_variable_length_onion(this_arg: number): boolean {
27846 if(!isWasmInitialized) {
27847 throw new Error("initializeWasm() must be awaited first!");
27849 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
27850 return nativeResponseValue;
27852 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27854 export function NodeFeatures_set_variable_length_onion_optional(this_arg: number): void {
27855 if(!isWasmInitialized) {
27856 throw new Error("initializeWasm() must be awaited first!");
27858 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
27859 // debug statements here
27861 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27863 export function NodeFeatures_set_variable_length_onion_required(this_arg: number): void {
27864 if(!isWasmInitialized) {
27865 throw new Error("initializeWasm() must be awaited first!");
27867 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
27868 // debug statements here
27870 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27872 export function NodeFeatures_supports_variable_length_onion(this_arg: number): boolean {
27873 if(!isWasmInitialized) {
27874 throw new Error("initializeWasm() must be awaited first!");
27876 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
27877 return nativeResponseValue;
27879 // void InvoiceFeatures_set_variable_length_onion_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27881 export function InvoiceFeatures_set_variable_length_onion_optional(this_arg: number): void {
27882 if(!isWasmInitialized) {
27883 throw new Error("initializeWasm() must be awaited first!");
27885 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_optional(this_arg);
27886 // debug statements here
27888 // void InvoiceFeatures_set_variable_length_onion_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27890 export function InvoiceFeatures_set_variable_length_onion_required(this_arg: number): void {
27891 if(!isWasmInitialized) {
27892 throw new Error("initializeWasm() must be awaited first!");
27894 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_required(this_arg);
27895 // debug statements here
27897 // MUST_USE_RES bool InvoiceFeatures_supports_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27899 export function InvoiceFeatures_supports_variable_length_onion(this_arg: number): boolean {
27900 if(!isWasmInitialized) {
27901 throw new Error("initializeWasm() must be awaited first!");
27903 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_variable_length_onion(this_arg);
27904 return nativeResponseValue;
27906 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27908 export function InitFeatures_requires_variable_length_onion(this_arg: number): boolean {
27909 if(!isWasmInitialized) {
27910 throw new Error("initializeWasm() must be awaited first!");
27912 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
27913 return nativeResponseValue;
27915 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27917 export function NodeFeatures_requires_variable_length_onion(this_arg: number): boolean {
27918 if(!isWasmInitialized) {
27919 throw new Error("initializeWasm() must be awaited first!");
27921 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
27922 return nativeResponseValue;
27924 // MUST_USE_RES bool InvoiceFeatures_requires_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27926 export function InvoiceFeatures_requires_variable_length_onion(this_arg: number): boolean {
27927 if(!isWasmInitialized) {
27928 throw new Error("initializeWasm() must be awaited first!");
27930 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_variable_length_onion(this_arg);
27931 return nativeResponseValue;
27933 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27935 export function InitFeatures_set_static_remote_key_optional(this_arg: number): void {
27936 if(!isWasmInitialized) {
27937 throw new Error("initializeWasm() must be awaited first!");
27939 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
27940 // debug statements here
27942 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27944 export function InitFeatures_set_static_remote_key_required(this_arg: number): void {
27945 if(!isWasmInitialized) {
27946 throw new Error("initializeWasm() must be awaited first!");
27948 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
27949 // debug statements here
27951 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27953 export function InitFeatures_supports_static_remote_key(this_arg: number): boolean {
27954 if(!isWasmInitialized) {
27955 throw new Error("initializeWasm() must be awaited first!");
27957 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
27958 return nativeResponseValue;
27960 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27962 export function NodeFeatures_set_static_remote_key_optional(this_arg: number): void {
27963 if(!isWasmInitialized) {
27964 throw new Error("initializeWasm() must be awaited first!");
27966 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
27967 // debug statements here
27969 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27971 export function NodeFeatures_set_static_remote_key_required(this_arg: number): void {
27972 if(!isWasmInitialized) {
27973 throw new Error("initializeWasm() must be awaited first!");
27975 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
27976 // debug statements here
27978 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27980 export function NodeFeatures_supports_static_remote_key(this_arg: number): boolean {
27981 if(!isWasmInitialized) {
27982 throw new Error("initializeWasm() must be awaited first!");
27984 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
27985 return nativeResponseValue;
27987 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27989 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: number): void {
27990 if(!isWasmInitialized) {
27991 throw new Error("initializeWasm() must be awaited first!");
27993 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
27994 // debug statements here
27996 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27998 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: number): void {
27999 if(!isWasmInitialized) {
28000 throw new Error("initializeWasm() must be awaited first!");
28002 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
28003 // debug statements here
28005 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28007 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: number): boolean {
28008 if(!isWasmInitialized) {
28009 throw new Error("initializeWasm() must be awaited first!");
28011 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
28012 return nativeResponseValue;
28014 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28016 export function InitFeatures_requires_static_remote_key(this_arg: number): boolean {
28017 if(!isWasmInitialized) {
28018 throw new Error("initializeWasm() must be awaited first!");
28020 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
28021 return nativeResponseValue;
28023 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28025 export function NodeFeatures_requires_static_remote_key(this_arg: number): boolean {
28026 if(!isWasmInitialized) {
28027 throw new Error("initializeWasm() must be awaited first!");
28029 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
28030 return nativeResponseValue;
28032 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28034 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: number): boolean {
28035 if(!isWasmInitialized) {
28036 throw new Error("initializeWasm() must be awaited first!");
28038 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
28039 return nativeResponseValue;
28041 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28043 export function InitFeatures_set_payment_secret_optional(this_arg: number): void {
28044 if(!isWasmInitialized) {
28045 throw new Error("initializeWasm() must be awaited first!");
28047 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
28048 // debug statements here
28050 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28052 export function InitFeatures_set_payment_secret_required(this_arg: number): void {
28053 if(!isWasmInitialized) {
28054 throw new Error("initializeWasm() must be awaited first!");
28056 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
28057 // debug statements here
28059 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28061 export function InitFeatures_supports_payment_secret(this_arg: number): boolean {
28062 if(!isWasmInitialized) {
28063 throw new Error("initializeWasm() must be awaited first!");
28065 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
28066 return nativeResponseValue;
28068 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28070 export function NodeFeatures_set_payment_secret_optional(this_arg: number): void {
28071 if(!isWasmInitialized) {
28072 throw new Error("initializeWasm() must be awaited first!");
28074 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
28075 // debug statements here
28077 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28079 export function NodeFeatures_set_payment_secret_required(this_arg: number): void {
28080 if(!isWasmInitialized) {
28081 throw new Error("initializeWasm() must be awaited first!");
28083 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
28084 // debug statements here
28086 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28088 export function NodeFeatures_supports_payment_secret(this_arg: number): boolean {
28089 if(!isWasmInitialized) {
28090 throw new Error("initializeWasm() must be awaited first!");
28092 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
28093 return nativeResponseValue;
28095 // void InvoiceFeatures_set_payment_secret_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28097 export function InvoiceFeatures_set_payment_secret_optional(this_arg: number): void {
28098 if(!isWasmInitialized) {
28099 throw new Error("initializeWasm() must be awaited first!");
28101 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_optional(this_arg);
28102 // debug statements here
28104 // void InvoiceFeatures_set_payment_secret_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28106 export function InvoiceFeatures_set_payment_secret_required(this_arg: number): void {
28107 if(!isWasmInitialized) {
28108 throw new Error("initializeWasm() must be awaited first!");
28110 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_required(this_arg);
28111 // debug statements here
28113 // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28115 export function InvoiceFeatures_supports_payment_secret(this_arg: number): boolean {
28116 if(!isWasmInitialized) {
28117 throw new Error("initializeWasm() must be awaited first!");
28119 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_payment_secret(this_arg);
28120 return nativeResponseValue;
28122 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28124 export function InitFeatures_requires_payment_secret(this_arg: number): boolean {
28125 if(!isWasmInitialized) {
28126 throw new Error("initializeWasm() must be awaited first!");
28128 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
28129 return nativeResponseValue;
28131 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28133 export function NodeFeatures_requires_payment_secret(this_arg: number): boolean {
28134 if(!isWasmInitialized) {
28135 throw new Error("initializeWasm() must be awaited first!");
28137 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
28138 return nativeResponseValue;
28140 // MUST_USE_RES bool InvoiceFeatures_requires_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28142 export function InvoiceFeatures_requires_payment_secret(this_arg: number): boolean {
28143 if(!isWasmInitialized) {
28144 throw new Error("initializeWasm() must be awaited first!");
28146 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_payment_secret(this_arg);
28147 return nativeResponseValue;
28149 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28151 export function InitFeatures_set_basic_mpp_optional(this_arg: number): void {
28152 if(!isWasmInitialized) {
28153 throw new Error("initializeWasm() must be awaited first!");
28155 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
28156 // debug statements here
28158 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28160 export function InitFeatures_set_basic_mpp_required(this_arg: number): void {
28161 if(!isWasmInitialized) {
28162 throw new Error("initializeWasm() must be awaited first!");
28164 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
28165 // debug statements here
28167 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28169 export function InitFeatures_supports_basic_mpp(this_arg: number): boolean {
28170 if(!isWasmInitialized) {
28171 throw new Error("initializeWasm() must be awaited first!");
28173 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
28174 return nativeResponseValue;
28176 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28178 export function NodeFeatures_set_basic_mpp_optional(this_arg: number): void {
28179 if(!isWasmInitialized) {
28180 throw new Error("initializeWasm() must be awaited first!");
28182 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
28183 // debug statements here
28185 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28187 export function NodeFeatures_set_basic_mpp_required(this_arg: number): void {
28188 if(!isWasmInitialized) {
28189 throw new Error("initializeWasm() must be awaited first!");
28191 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
28192 // debug statements here
28194 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28196 export function NodeFeatures_supports_basic_mpp(this_arg: number): boolean {
28197 if(!isWasmInitialized) {
28198 throw new Error("initializeWasm() must be awaited first!");
28200 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
28201 return nativeResponseValue;
28203 // void InvoiceFeatures_set_basic_mpp_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28205 export function InvoiceFeatures_set_basic_mpp_optional(this_arg: number): void {
28206 if(!isWasmInitialized) {
28207 throw new Error("initializeWasm() must be awaited first!");
28209 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_optional(this_arg);
28210 // debug statements here
28212 // void InvoiceFeatures_set_basic_mpp_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28214 export function InvoiceFeatures_set_basic_mpp_required(this_arg: number): void {
28215 if(!isWasmInitialized) {
28216 throw new Error("initializeWasm() must be awaited first!");
28218 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_required(this_arg);
28219 // debug statements here
28221 // MUST_USE_RES bool InvoiceFeatures_supports_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28223 export function InvoiceFeatures_supports_basic_mpp(this_arg: number): boolean {
28224 if(!isWasmInitialized) {
28225 throw new Error("initializeWasm() must be awaited first!");
28227 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_basic_mpp(this_arg);
28228 return nativeResponseValue;
28230 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28232 export function InitFeatures_requires_basic_mpp(this_arg: number): boolean {
28233 if(!isWasmInitialized) {
28234 throw new Error("initializeWasm() must be awaited first!");
28236 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
28237 return nativeResponseValue;
28239 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28241 export function NodeFeatures_requires_basic_mpp(this_arg: number): boolean {
28242 if(!isWasmInitialized) {
28243 throw new Error("initializeWasm() must be awaited first!");
28245 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
28246 return nativeResponseValue;
28248 // MUST_USE_RES bool InvoiceFeatures_requires_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
28250 export function InvoiceFeatures_requires_basic_mpp(this_arg: number): boolean {
28251 if(!isWasmInitialized) {
28252 throw new Error("initializeWasm() must be awaited first!");
28254 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_basic_mpp(this_arg);
28255 return nativeResponseValue;
28257 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28259 export function InitFeatures_set_wumbo_optional(this_arg: number): void {
28260 if(!isWasmInitialized) {
28261 throw new Error("initializeWasm() must be awaited first!");
28263 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
28264 // debug statements here
28266 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28268 export function InitFeatures_set_wumbo_required(this_arg: number): void {
28269 if(!isWasmInitialized) {
28270 throw new Error("initializeWasm() must be awaited first!");
28272 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
28273 // debug statements here
28275 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28277 export function InitFeatures_supports_wumbo(this_arg: number): boolean {
28278 if(!isWasmInitialized) {
28279 throw new Error("initializeWasm() must be awaited first!");
28281 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
28282 return nativeResponseValue;
28284 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28286 export function NodeFeatures_set_wumbo_optional(this_arg: number): void {
28287 if(!isWasmInitialized) {
28288 throw new Error("initializeWasm() must be awaited first!");
28290 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
28291 // debug statements here
28293 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28295 export function NodeFeatures_set_wumbo_required(this_arg: number): void {
28296 if(!isWasmInitialized) {
28297 throw new Error("initializeWasm() must be awaited first!");
28299 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
28300 // debug statements here
28302 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28304 export function NodeFeatures_supports_wumbo(this_arg: number): boolean {
28305 if(!isWasmInitialized) {
28306 throw new Error("initializeWasm() must be awaited first!");
28308 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
28309 return nativeResponseValue;
28311 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28313 export function InitFeatures_requires_wumbo(this_arg: number): boolean {
28314 if(!isWasmInitialized) {
28315 throw new Error("initializeWasm() must be awaited first!");
28317 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
28318 return nativeResponseValue;
28320 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28322 export function NodeFeatures_requires_wumbo(this_arg: number): boolean {
28323 if(!isWasmInitialized) {
28324 throw new Error("initializeWasm() must be awaited first!");
28326 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
28327 return nativeResponseValue;
28329 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28331 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: number): void {
28332 if(!isWasmInitialized) {
28333 throw new Error("initializeWasm() must be awaited first!");
28335 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
28336 // debug statements here
28338 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28340 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: number): void {
28341 if(!isWasmInitialized) {
28342 throw new Error("initializeWasm() must be awaited first!");
28344 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
28345 // debug statements here
28347 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28349 export function InitFeatures_supports_shutdown_anysegwit(this_arg: number): boolean {
28350 if(!isWasmInitialized) {
28351 throw new Error("initializeWasm() must be awaited first!");
28353 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
28354 return nativeResponseValue;
28356 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28358 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: number): void {
28359 if(!isWasmInitialized) {
28360 throw new Error("initializeWasm() must be awaited first!");
28362 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
28363 // debug statements here
28365 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28367 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: number): void {
28368 if(!isWasmInitialized) {
28369 throw new Error("initializeWasm() must be awaited first!");
28371 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
28372 // debug statements here
28374 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28376 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: number): boolean {
28377 if(!isWasmInitialized) {
28378 throw new Error("initializeWasm() must be awaited first!");
28380 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
28381 return nativeResponseValue;
28383 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28385 export function InitFeatures_requires_shutdown_anysegwit(this_arg: number): boolean {
28386 if(!isWasmInitialized) {
28387 throw new Error("initializeWasm() must be awaited first!");
28389 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
28390 return nativeResponseValue;
28392 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28394 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: number): boolean {
28395 if(!isWasmInitialized) {
28396 throw new Error("initializeWasm() must be awaited first!");
28398 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
28399 return nativeResponseValue;
28401 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28403 export function InitFeatures_set_channel_type_optional(this_arg: number): void {
28404 if(!isWasmInitialized) {
28405 throw new Error("initializeWasm() must be awaited first!");
28407 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
28408 // debug statements here
28410 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28412 export function InitFeatures_set_channel_type_required(this_arg: number): void {
28413 if(!isWasmInitialized) {
28414 throw new Error("initializeWasm() must be awaited first!");
28416 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
28417 // debug statements here
28419 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28421 export function InitFeatures_supports_channel_type(this_arg: number): boolean {
28422 if(!isWasmInitialized) {
28423 throw new Error("initializeWasm() must be awaited first!");
28425 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
28426 return nativeResponseValue;
28428 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28430 export function NodeFeatures_set_channel_type_optional(this_arg: number): void {
28431 if(!isWasmInitialized) {
28432 throw new Error("initializeWasm() must be awaited first!");
28434 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
28435 // debug statements here
28437 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28439 export function NodeFeatures_set_channel_type_required(this_arg: number): void {
28440 if(!isWasmInitialized) {
28441 throw new Error("initializeWasm() must be awaited first!");
28443 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
28444 // debug statements here
28446 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28448 export function NodeFeatures_supports_channel_type(this_arg: number): boolean {
28449 if(!isWasmInitialized) {
28450 throw new Error("initializeWasm() must be awaited first!");
28452 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
28453 return nativeResponseValue;
28455 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28457 export function InitFeatures_requires_channel_type(this_arg: number): boolean {
28458 if(!isWasmInitialized) {
28459 throw new Error("initializeWasm() must be awaited first!");
28461 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
28462 return nativeResponseValue;
28464 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28466 export function NodeFeatures_requires_channel_type(this_arg: number): boolean {
28467 if(!isWasmInitialized) {
28468 throw new Error("initializeWasm() must be awaited first!");
28470 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
28471 return nativeResponseValue;
28473 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28475 export function InitFeatures_set_scid_privacy_optional(this_arg: number): void {
28476 if(!isWasmInitialized) {
28477 throw new Error("initializeWasm() must be awaited first!");
28479 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
28480 // debug statements here
28482 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28484 export function InitFeatures_set_scid_privacy_required(this_arg: number): void {
28485 if(!isWasmInitialized) {
28486 throw new Error("initializeWasm() must be awaited first!");
28488 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
28489 // debug statements here
28491 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28493 export function InitFeatures_supports_scid_privacy(this_arg: number): boolean {
28494 if(!isWasmInitialized) {
28495 throw new Error("initializeWasm() must be awaited first!");
28497 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
28498 return nativeResponseValue;
28500 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28502 export function NodeFeatures_set_scid_privacy_optional(this_arg: number): void {
28503 if(!isWasmInitialized) {
28504 throw new Error("initializeWasm() must be awaited first!");
28506 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
28507 // debug statements here
28509 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28511 export function NodeFeatures_set_scid_privacy_required(this_arg: number): void {
28512 if(!isWasmInitialized) {
28513 throw new Error("initializeWasm() must be awaited first!");
28515 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
28516 // debug statements here
28518 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28520 export function NodeFeatures_supports_scid_privacy(this_arg: number): boolean {
28521 if(!isWasmInitialized) {
28522 throw new Error("initializeWasm() must be awaited first!");
28524 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
28525 return nativeResponseValue;
28527 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28529 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: number): void {
28530 if(!isWasmInitialized) {
28531 throw new Error("initializeWasm() must be awaited first!");
28533 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
28534 // debug statements here
28536 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28538 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: number): void {
28539 if(!isWasmInitialized) {
28540 throw new Error("initializeWasm() must be awaited first!");
28542 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
28543 // debug statements here
28545 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28547 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: number): boolean {
28548 if(!isWasmInitialized) {
28549 throw new Error("initializeWasm() must be awaited first!");
28551 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
28552 return nativeResponseValue;
28554 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28556 export function InitFeatures_requires_scid_privacy(this_arg: number): boolean {
28557 if(!isWasmInitialized) {
28558 throw new Error("initializeWasm() must be awaited first!");
28560 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
28561 return nativeResponseValue;
28563 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28565 export function NodeFeatures_requires_scid_privacy(this_arg: number): boolean {
28566 if(!isWasmInitialized) {
28567 throw new Error("initializeWasm() must be awaited first!");
28569 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
28570 return nativeResponseValue;
28572 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28574 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: number): boolean {
28575 if(!isWasmInitialized) {
28576 throw new Error("initializeWasm() must be awaited first!");
28578 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
28579 return nativeResponseValue;
28581 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28583 export function InitFeatures_set_zero_conf_optional(this_arg: number): void {
28584 if(!isWasmInitialized) {
28585 throw new Error("initializeWasm() must be awaited first!");
28587 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
28588 // debug statements here
28590 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28592 export function InitFeatures_set_zero_conf_required(this_arg: number): void {
28593 if(!isWasmInitialized) {
28594 throw new Error("initializeWasm() must be awaited first!");
28596 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
28597 // debug statements here
28599 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28601 export function InitFeatures_supports_zero_conf(this_arg: number): boolean {
28602 if(!isWasmInitialized) {
28603 throw new Error("initializeWasm() must be awaited first!");
28605 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
28606 return nativeResponseValue;
28608 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28610 export function NodeFeatures_set_zero_conf_optional(this_arg: number): void {
28611 if(!isWasmInitialized) {
28612 throw new Error("initializeWasm() must be awaited first!");
28614 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
28615 // debug statements here
28617 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28619 export function NodeFeatures_set_zero_conf_required(this_arg: number): void {
28620 if(!isWasmInitialized) {
28621 throw new Error("initializeWasm() must be awaited first!");
28623 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
28624 // debug statements here
28626 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28628 export function NodeFeatures_supports_zero_conf(this_arg: number): boolean {
28629 if(!isWasmInitialized) {
28630 throw new Error("initializeWasm() must be awaited first!");
28632 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
28633 return nativeResponseValue;
28635 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28637 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: number): void {
28638 if(!isWasmInitialized) {
28639 throw new Error("initializeWasm() must be awaited first!");
28641 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
28642 // debug statements here
28644 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28646 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: number): void {
28647 if(!isWasmInitialized) {
28648 throw new Error("initializeWasm() must be awaited first!");
28650 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
28651 // debug statements here
28653 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28655 export function ChannelTypeFeatures_supports_zero_conf(this_arg: number): boolean {
28656 if(!isWasmInitialized) {
28657 throw new Error("initializeWasm() must be awaited first!");
28659 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
28660 return nativeResponseValue;
28662 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28664 export function InitFeatures_requires_zero_conf(this_arg: number): boolean {
28665 if(!isWasmInitialized) {
28666 throw new Error("initializeWasm() must be awaited first!");
28668 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
28669 return nativeResponseValue;
28671 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28673 export function NodeFeatures_requires_zero_conf(this_arg: number): boolean {
28674 if(!isWasmInitialized) {
28675 throw new Error("initializeWasm() must be awaited first!");
28677 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
28678 return nativeResponseValue;
28680 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28682 export function ChannelTypeFeatures_requires_zero_conf(this_arg: number): boolean {
28683 if(!isWasmInitialized) {
28684 throw new Error("initializeWasm() must be awaited first!");
28686 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
28687 return nativeResponseValue;
28689 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28691 export function NodeFeatures_set_keysend_optional(this_arg: number): void {
28692 if(!isWasmInitialized) {
28693 throw new Error("initializeWasm() must be awaited first!");
28695 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
28696 // debug statements here
28698 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28700 export function NodeFeatures_set_keysend_required(this_arg: number): void {
28701 if(!isWasmInitialized) {
28702 throw new Error("initializeWasm() must be awaited first!");
28704 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
28705 // debug statements here
28707 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28709 export function NodeFeatures_supports_keysend(this_arg: number): boolean {
28710 if(!isWasmInitialized) {
28711 throw new Error("initializeWasm() must be awaited first!");
28713 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
28714 return nativeResponseValue;
28716 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28718 export function NodeFeatures_requires_keysend(this_arg: number): boolean {
28719 if(!isWasmInitialized) {
28720 throw new Error("initializeWasm() must be awaited first!");
28722 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
28723 return nativeResponseValue;
28725 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
28727 export function ShutdownScript_free(this_obj: number): void {
28728 if(!isWasmInitialized) {
28729 throw new Error("initializeWasm() must be awaited first!");
28731 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
28732 // debug statements here
28734 // uintptr_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
28736 export function ShutdownScript_clone_ptr(arg: number): number {
28737 if(!isWasmInitialized) {
28738 throw new Error("initializeWasm() must be awaited first!");
28740 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
28741 return nativeResponseValue;
28743 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
28745 export function ShutdownScript_clone(orig: number): number {
28746 if(!isWasmInitialized) {
28747 throw new Error("initializeWasm() must be awaited first!");
28749 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
28750 return nativeResponseValue;
28752 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
28754 export function InvalidShutdownScript_free(this_obj: number): void {
28755 if(!isWasmInitialized) {
28756 throw new Error("initializeWasm() must be awaited first!");
28758 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
28759 // debug statements here
28761 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
28763 export function InvalidShutdownScript_get_script(this_ptr: number): number {
28764 if(!isWasmInitialized) {
28765 throw new Error("initializeWasm() must be awaited first!");
28767 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
28768 return nativeResponseValue;
28770 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
28772 export function InvalidShutdownScript_set_script(this_ptr: number, val: number): void {
28773 if(!isWasmInitialized) {
28774 throw new Error("initializeWasm() must be awaited first!");
28776 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
28777 // debug statements here
28779 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
28781 export function InvalidShutdownScript_new(script_arg: number): number {
28782 if(!isWasmInitialized) {
28783 throw new Error("initializeWasm() must be awaited first!");
28785 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
28786 return nativeResponseValue;
28788 // uintptr_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
28790 export function InvalidShutdownScript_clone_ptr(arg: number): number {
28791 if(!isWasmInitialized) {
28792 throw new Error("initializeWasm() must be awaited first!");
28794 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
28795 return nativeResponseValue;
28797 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
28799 export function InvalidShutdownScript_clone(orig: number): number {
28800 if(!isWasmInitialized) {
28801 throw new Error("initializeWasm() must be awaited first!");
28803 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
28804 return nativeResponseValue;
28806 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
28808 export function ShutdownScript_write(obj: number): number {
28809 if(!isWasmInitialized) {
28810 throw new Error("initializeWasm() must be awaited first!");
28812 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
28813 return nativeResponseValue;
28815 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
28817 export function ShutdownScript_read(ser: number): number {
28818 if(!isWasmInitialized) {
28819 throw new Error("initializeWasm() must be awaited first!");
28821 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
28822 return nativeResponseValue;
28824 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
28826 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): number {
28827 if(!isWasmInitialized) {
28828 throw new Error("initializeWasm() must be awaited first!");
28830 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
28831 return nativeResponseValue;
28833 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
28835 export function ShutdownScript_new_p2wsh(script_hash: number): number {
28836 if(!isWasmInitialized) {
28837 throw new Error("initializeWasm() must be awaited first!");
28839 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
28840 return nativeResponseValue;
28842 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
28844 export function ShutdownScript_new_witness_program(version: number, program: number): number {
28845 if(!isWasmInitialized) {
28846 throw new Error("initializeWasm() must be awaited first!");
28848 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
28849 return nativeResponseValue;
28851 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
28853 export function ShutdownScript_into_inner(this_arg: number): number {
28854 if(!isWasmInitialized) {
28855 throw new Error("initializeWasm() must be awaited first!");
28857 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
28858 return nativeResponseValue;
28860 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
28862 export function ShutdownScript_as_legacy_pubkey(this_arg: number): number {
28863 if(!isWasmInitialized) {
28864 throw new Error("initializeWasm() must be awaited first!");
28866 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
28867 return nativeResponseValue;
28869 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
28871 export function ShutdownScript_is_compatible(this_arg: number, features: number): boolean {
28872 if(!isWasmInitialized) {
28873 throw new Error("initializeWasm() must be awaited first!");
28875 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
28876 return nativeResponseValue;
28878 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
28880 export function CustomMessageReader_free(this_ptr: number): void {
28881 if(!isWasmInitialized) {
28882 throw new Error("initializeWasm() must be awaited first!");
28884 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
28885 // debug statements here
28887 // uintptr_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
28889 export function Type_clone_ptr(arg: number): number {
28890 if(!isWasmInitialized) {
28891 throw new Error("initializeWasm() must be awaited first!");
28893 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
28894 return nativeResponseValue;
28896 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
28898 export function Type_clone(orig: number): number {
28899 if(!isWasmInitialized) {
28900 throw new Error("initializeWasm() must be awaited first!");
28902 const nativeResponseValue = wasm.TS_Type_clone(orig);
28903 return nativeResponseValue;
28905 // void Type_free(struct LDKType this_ptr);
28907 export function Type_free(this_ptr: number): void {
28908 if(!isWasmInitialized) {
28909 throw new Error("initializeWasm() must be awaited first!");
28911 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
28912 // debug statements here
28914 // void NodeId_free(struct LDKNodeId this_obj);
28916 export function NodeId_free(this_obj: number): void {
28917 if(!isWasmInitialized) {
28918 throw new Error("initializeWasm() must be awaited first!");
28920 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
28921 // debug statements here
28923 // uintptr_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
28925 export function NodeId_clone_ptr(arg: number): number {
28926 if(!isWasmInitialized) {
28927 throw new Error("initializeWasm() must be awaited first!");
28929 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
28930 return nativeResponseValue;
28932 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
28934 export function NodeId_clone(orig: number): number {
28935 if(!isWasmInitialized) {
28936 throw new Error("initializeWasm() must be awaited first!");
28938 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
28939 return nativeResponseValue;
28941 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
28943 export function NodeId_from_pubkey(pubkey: number): number {
28944 if(!isWasmInitialized) {
28945 throw new Error("initializeWasm() must be awaited first!");
28947 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
28948 return nativeResponseValue;
28950 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
28952 export function NodeId_as_slice(this_arg: number): number {
28953 if(!isWasmInitialized) {
28954 throw new Error("initializeWasm() must be awaited first!");
28956 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
28957 return nativeResponseValue;
28959 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
28961 export function NodeId_hash(o: number): bigint {
28962 if(!isWasmInitialized) {
28963 throw new Error("initializeWasm() must be awaited first!");
28965 const nativeResponseValue = wasm.TS_NodeId_hash(o);
28966 return nativeResponseValue;
28968 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
28970 export function NodeId_write(obj: number): number {
28971 if(!isWasmInitialized) {
28972 throw new Error("initializeWasm() must be awaited first!");
28974 const nativeResponseValue = wasm.TS_NodeId_write(obj);
28975 return nativeResponseValue;
28977 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
28979 export function NodeId_read(ser: number): number {
28980 if(!isWasmInitialized) {
28981 throw new Error("initializeWasm() must be awaited first!");
28983 const nativeResponseValue = wasm.TS_NodeId_read(ser);
28984 return nativeResponseValue;
28986 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
28988 export function NetworkGraph_free(this_obj: number): void {
28989 if(!isWasmInitialized) {
28990 throw new Error("initializeWasm() must be awaited first!");
28992 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
28993 // debug statements here
28995 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
28997 export function ReadOnlyNetworkGraph_free(this_obj: number): void {
28998 if(!isWasmInitialized) {
28999 throw new Error("initializeWasm() must be awaited first!");
29001 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
29002 // debug statements here
29004 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
29006 export function NetworkUpdate_free(this_ptr: number): void {
29007 if(!isWasmInitialized) {
29008 throw new Error("initializeWasm() must be awaited first!");
29010 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
29011 // debug statements here
29013 // uintptr_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
29015 export function NetworkUpdate_clone_ptr(arg: number): number {
29016 if(!isWasmInitialized) {
29017 throw new Error("initializeWasm() must be awaited first!");
29019 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
29020 return nativeResponseValue;
29022 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
29024 export function NetworkUpdate_clone(orig: number): number {
29025 if(!isWasmInitialized) {
29026 throw new Error("initializeWasm() must be awaited first!");
29028 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
29029 return nativeResponseValue;
29031 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
29033 export function NetworkUpdate_channel_update_message(msg: number): number {
29034 if(!isWasmInitialized) {
29035 throw new Error("initializeWasm() must be awaited first!");
29037 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
29038 return nativeResponseValue;
29040 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
29042 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): number {
29043 if(!isWasmInitialized) {
29044 throw new Error("initializeWasm() must be awaited first!");
29046 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
29047 return nativeResponseValue;
29049 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
29051 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): number {
29052 if(!isWasmInitialized) {
29053 throw new Error("initializeWasm() must be awaited first!");
29055 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
29056 return nativeResponseValue;
29058 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
29060 export function NetworkUpdate_write(obj: number): number {
29061 if(!isWasmInitialized) {
29062 throw new Error("initializeWasm() must be awaited first!");
29064 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
29065 return nativeResponseValue;
29067 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
29069 export function NetworkUpdate_read(ser: number): number {
29070 if(!isWasmInitialized) {
29071 throw new Error("initializeWasm() must be awaited first!");
29073 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
29074 return nativeResponseValue;
29076 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
29078 export function P2PGossipSync_free(this_obj: number): void {
29079 if(!isWasmInitialized) {
29080 throw new Error("initializeWasm() must be awaited first!");
29082 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
29083 // debug statements here
29085 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
29087 export function P2PGossipSync_new(network_graph: number, chain_access: number, logger: number): number {
29088 if(!isWasmInitialized) {
29089 throw new Error("initializeWasm() must be awaited first!");
29091 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, chain_access, logger);
29092 return nativeResponseValue;
29094 // void P2PGossipSync_add_chain_access(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
29096 export function P2PGossipSync_add_chain_access(this_arg: number, chain_access: number): void {
29097 if(!isWasmInitialized) {
29098 throw new Error("initializeWasm() must be awaited first!");
29100 const nativeResponseValue = wasm.TS_P2PGossipSync_add_chain_access(this_arg, chain_access);
29101 // debug statements here
29103 // struct LDKEventHandler NetworkGraph_as_EventHandler(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
29105 export function NetworkGraph_as_EventHandler(this_arg: number): number {
29106 if(!isWasmInitialized) {
29107 throw new Error("initializeWasm() must be awaited first!");
29109 const nativeResponseValue = wasm.TS_NetworkGraph_as_EventHandler(this_arg);
29110 return nativeResponseValue;
29112 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
29114 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: number): number {
29115 if(!isWasmInitialized) {
29116 throw new Error("initializeWasm() must be awaited first!");
29118 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
29119 return nativeResponseValue;
29121 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
29123 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: number): number {
29124 if(!isWasmInitialized) {
29125 throw new Error("initializeWasm() must be awaited first!");
29127 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
29128 return nativeResponseValue;
29130 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
29132 export function ChannelUpdateInfo_free(this_obj: number): void {
29133 if(!isWasmInitialized) {
29134 throw new Error("initializeWasm() must be awaited first!");
29136 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
29137 // debug statements here
29139 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29141 export function ChannelUpdateInfo_get_last_update(this_ptr: number): number {
29142 if(!isWasmInitialized) {
29143 throw new Error("initializeWasm() must be awaited first!");
29145 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
29146 return nativeResponseValue;
29148 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
29150 export function ChannelUpdateInfo_set_last_update(this_ptr: number, val: number): void {
29151 if(!isWasmInitialized) {
29152 throw new Error("initializeWasm() must be awaited first!");
29154 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
29155 // debug statements here
29157 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29159 export function ChannelUpdateInfo_get_enabled(this_ptr: number): boolean {
29160 if(!isWasmInitialized) {
29161 throw new Error("initializeWasm() must be awaited first!");
29163 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
29164 return nativeResponseValue;
29166 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
29168 export function ChannelUpdateInfo_set_enabled(this_ptr: number, val: boolean): void {
29169 if(!isWasmInitialized) {
29170 throw new Error("initializeWasm() must be awaited first!");
29172 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
29173 // debug statements here
29175 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29177 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: number): number {
29178 if(!isWasmInitialized) {
29179 throw new Error("initializeWasm() must be awaited first!");
29181 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
29182 return nativeResponseValue;
29184 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
29186 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
29187 if(!isWasmInitialized) {
29188 throw new Error("initializeWasm() must be awaited first!");
29190 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
29191 // debug statements here
29193 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29195 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: number): bigint {
29196 if(!isWasmInitialized) {
29197 throw new Error("initializeWasm() must be awaited first!");
29199 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
29200 return nativeResponseValue;
29202 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
29204 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
29205 if(!isWasmInitialized) {
29206 throw new Error("initializeWasm() must be awaited first!");
29208 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
29209 // debug statements here
29211 // uint64_t ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29213 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: number): bigint {
29214 if(!isWasmInitialized) {
29215 throw new Error("initializeWasm() must be awaited first!");
29217 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
29218 return nativeResponseValue;
29220 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
29222 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: number, val: bigint): void {
29223 if(!isWasmInitialized) {
29224 throw new Error("initializeWasm() must be awaited first!");
29226 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
29227 // debug statements here
29229 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29231 export function ChannelUpdateInfo_get_fees(this_ptr: number): number {
29232 if(!isWasmInitialized) {
29233 throw new Error("initializeWasm() must be awaited first!");
29235 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
29236 return nativeResponseValue;
29238 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
29240 export function ChannelUpdateInfo_set_fees(this_ptr: number, val: number): void {
29241 if(!isWasmInitialized) {
29242 throw new Error("initializeWasm() must be awaited first!");
29244 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
29245 // debug statements here
29247 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
29249 export function ChannelUpdateInfo_get_last_update_message(this_ptr: number): number {
29250 if(!isWasmInitialized) {
29251 throw new Error("initializeWasm() must be awaited first!");
29253 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
29254 return nativeResponseValue;
29256 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
29258 export function ChannelUpdateInfo_set_last_update_message(this_ptr: number, val: number): void {
29259 if(!isWasmInitialized) {
29260 throw new Error("initializeWasm() must be awaited first!");
29262 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
29263 // debug statements here
29265 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelUpdateInfo_new(uint32_t last_update_arg, bool enabled_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, uint64_t htlc_maximum_msat_arg, struct LDKRoutingFees fees_arg, struct LDKChannelUpdate last_update_message_arg);
29267 export function ChannelUpdateInfo_new(last_update_arg: number, enabled_arg: boolean, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: bigint, fees_arg: number, last_update_message_arg: number): number {
29268 if(!isWasmInitialized) {
29269 throw new Error("initializeWasm() must be awaited first!");
29271 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);
29272 return nativeResponseValue;
29274 // uintptr_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
29276 export function ChannelUpdateInfo_clone_ptr(arg: number): number {
29277 if(!isWasmInitialized) {
29278 throw new Error("initializeWasm() must be awaited first!");
29280 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
29281 return nativeResponseValue;
29283 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
29285 export function ChannelUpdateInfo_clone(orig: number): number {
29286 if(!isWasmInitialized) {
29287 throw new Error("initializeWasm() must be awaited first!");
29289 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
29290 return nativeResponseValue;
29292 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
29294 export function ChannelUpdateInfo_write(obj: number): number {
29295 if(!isWasmInitialized) {
29296 throw new Error("initializeWasm() must be awaited first!");
29298 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
29299 return nativeResponseValue;
29301 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
29303 export function ChannelUpdateInfo_read(ser: number): number {
29304 if(!isWasmInitialized) {
29305 throw new Error("initializeWasm() must be awaited first!");
29307 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
29308 return nativeResponseValue;
29310 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
29312 export function ChannelInfo_free(this_obj: number): void {
29313 if(!isWasmInitialized) {
29314 throw new Error("initializeWasm() must be awaited first!");
29316 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
29317 // debug statements here
29319 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29321 export function ChannelInfo_get_features(this_ptr: number): number {
29322 if(!isWasmInitialized) {
29323 throw new Error("initializeWasm() must be awaited first!");
29325 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
29326 return nativeResponseValue;
29328 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
29330 export function ChannelInfo_set_features(this_ptr: number, val: number): void {
29331 if(!isWasmInitialized) {
29332 throw new Error("initializeWasm() must be awaited first!");
29334 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
29335 // debug statements here
29337 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29339 export function ChannelInfo_get_node_one(this_ptr: number): number {
29340 if(!isWasmInitialized) {
29341 throw new Error("initializeWasm() must be awaited first!");
29343 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
29344 return nativeResponseValue;
29346 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
29348 export function ChannelInfo_set_node_one(this_ptr: number, val: number): void {
29349 if(!isWasmInitialized) {
29350 throw new Error("initializeWasm() must be awaited first!");
29352 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
29353 // debug statements here
29355 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29357 export function ChannelInfo_get_one_to_two(this_ptr: number): number {
29358 if(!isWasmInitialized) {
29359 throw new Error("initializeWasm() must be awaited first!");
29361 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
29362 return nativeResponseValue;
29364 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
29366 export function ChannelInfo_set_one_to_two(this_ptr: number, val: number): void {
29367 if(!isWasmInitialized) {
29368 throw new Error("initializeWasm() must be awaited first!");
29370 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
29371 // debug statements here
29373 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29375 export function ChannelInfo_get_node_two(this_ptr: number): number {
29376 if(!isWasmInitialized) {
29377 throw new Error("initializeWasm() must be awaited first!");
29379 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
29380 return nativeResponseValue;
29382 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
29384 export function ChannelInfo_set_node_two(this_ptr: number, val: number): void {
29385 if(!isWasmInitialized) {
29386 throw new Error("initializeWasm() must be awaited first!");
29388 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
29389 // debug statements here
29391 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29393 export function ChannelInfo_get_two_to_one(this_ptr: number): number {
29394 if(!isWasmInitialized) {
29395 throw new Error("initializeWasm() must be awaited first!");
29397 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
29398 return nativeResponseValue;
29400 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
29402 export function ChannelInfo_set_two_to_one(this_ptr: number, val: number): void {
29403 if(!isWasmInitialized) {
29404 throw new Error("initializeWasm() must be awaited first!");
29406 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
29407 // debug statements here
29409 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29411 export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
29412 if(!isWasmInitialized) {
29413 throw new Error("initializeWasm() must be awaited first!");
29415 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
29416 return nativeResponseValue;
29418 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
29420 export function ChannelInfo_set_capacity_sats(this_ptr: number, val: number): void {
29421 if(!isWasmInitialized) {
29422 throw new Error("initializeWasm() must be awaited first!");
29424 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
29425 // debug statements here
29427 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
29429 export function ChannelInfo_get_announcement_message(this_ptr: number): number {
29430 if(!isWasmInitialized) {
29431 throw new Error("initializeWasm() must be awaited first!");
29433 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
29434 return nativeResponseValue;
29436 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
29438 export function ChannelInfo_set_announcement_message(this_ptr: number, val: number): void {
29439 if(!isWasmInitialized) {
29440 throw new Error("initializeWasm() must be awaited first!");
29442 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
29443 // debug statements here
29445 // uintptr_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
29447 export function ChannelInfo_clone_ptr(arg: number): number {
29448 if(!isWasmInitialized) {
29449 throw new Error("initializeWasm() must be awaited first!");
29451 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
29452 return nativeResponseValue;
29454 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
29456 export function ChannelInfo_clone(orig: number): number {
29457 if(!isWasmInitialized) {
29458 throw new Error("initializeWasm() must be awaited first!");
29460 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
29461 return nativeResponseValue;
29463 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
29465 export function ChannelInfo_get_directional_info(this_arg: number, channel_flags: number): number {
29466 if(!isWasmInitialized) {
29467 throw new Error("initializeWasm() must be awaited first!");
29469 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
29470 return nativeResponseValue;
29472 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
29474 export function ChannelInfo_write(obj: number): number {
29475 if(!isWasmInitialized) {
29476 throw new Error("initializeWasm() must be awaited first!");
29478 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
29479 return nativeResponseValue;
29481 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
29483 export function ChannelInfo_read(ser: number): number {
29484 if(!isWasmInitialized) {
29485 throw new Error("initializeWasm() must be awaited first!");
29487 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
29488 return nativeResponseValue;
29490 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
29492 export function DirectedChannelInfo_free(this_obj: number): void {
29493 if(!isWasmInitialized) {
29494 throw new Error("initializeWasm() must be awaited first!");
29496 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
29497 // debug statements here
29499 // uintptr_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
29501 export function DirectedChannelInfo_clone_ptr(arg: number): number {
29502 if(!isWasmInitialized) {
29503 throw new Error("initializeWasm() must be awaited first!");
29505 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
29506 return nativeResponseValue;
29508 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
29510 export function DirectedChannelInfo_clone(orig: number): number {
29511 if(!isWasmInitialized) {
29512 throw new Error("initializeWasm() must be awaited first!");
29514 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
29515 return nativeResponseValue;
29517 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29519 export function DirectedChannelInfo_channel(this_arg: number): number {
29520 if(!isWasmInitialized) {
29521 throw new Error("initializeWasm() must be awaited first!");
29523 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
29524 return nativeResponseValue;
29526 // MUST_USE_RES struct LDKChannelUpdateInfo DirectedChannelInfo_direction(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29528 export function DirectedChannelInfo_direction(this_arg: number): number {
29529 if(!isWasmInitialized) {
29530 throw new Error("initializeWasm() must be awaited first!");
29532 const nativeResponseValue = wasm.TS_DirectedChannelInfo_direction(this_arg);
29533 return nativeResponseValue;
29535 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29537 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: number): bigint {
29538 if(!isWasmInitialized) {
29539 throw new Error("initializeWasm() must be awaited first!");
29541 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
29542 return nativeResponseValue;
29544 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29546 export function DirectedChannelInfo_effective_capacity(this_arg: number): number {
29547 if(!isWasmInitialized) {
29548 throw new Error("initializeWasm() must be awaited first!");
29550 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
29551 return nativeResponseValue;
29553 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
29555 export function EffectiveCapacity_free(this_ptr: number): void {
29556 if(!isWasmInitialized) {
29557 throw new Error("initializeWasm() must be awaited first!");
29559 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
29560 // debug statements here
29562 // uintptr_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
29564 export function EffectiveCapacity_clone_ptr(arg: number): number {
29565 if(!isWasmInitialized) {
29566 throw new Error("initializeWasm() must be awaited first!");
29568 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
29569 return nativeResponseValue;
29571 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
29573 export function EffectiveCapacity_clone(orig: number): number {
29574 if(!isWasmInitialized) {
29575 throw new Error("initializeWasm() must be awaited first!");
29577 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
29578 return nativeResponseValue;
29580 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
29582 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): number {
29583 if(!isWasmInitialized) {
29584 throw new Error("initializeWasm() must be awaited first!");
29586 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
29587 return nativeResponseValue;
29589 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
29591 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): number {
29592 if(!isWasmInitialized) {
29593 throw new Error("initializeWasm() must be awaited first!");
29595 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
29596 return nativeResponseValue;
29598 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, struct LDKCOption_u64Z htlc_maximum_msat);
29600 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: number): number {
29601 if(!isWasmInitialized) {
29602 throw new Error("initializeWasm() must be awaited first!");
29604 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
29605 return nativeResponseValue;
29607 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
29609 export function EffectiveCapacity_infinite(): number {
29610 if(!isWasmInitialized) {
29611 throw new Error("initializeWasm() must be awaited first!");
29613 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
29614 return nativeResponseValue;
29616 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
29618 export function EffectiveCapacity_unknown(): number {
29619 if(!isWasmInitialized) {
29620 throw new Error("initializeWasm() must be awaited first!");
29622 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
29623 return nativeResponseValue;
29625 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
29627 export function EffectiveCapacity_as_msat(this_arg: number): bigint {
29628 if(!isWasmInitialized) {
29629 throw new Error("initializeWasm() must be awaited first!");
29631 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
29632 return nativeResponseValue;
29634 // void RoutingFees_free(struct LDKRoutingFees this_obj);
29636 export function RoutingFees_free(this_obj: number): void {
29637 if(!isWasmInitialized) {
29638 throw new Error("initializeWasm() must be awaited first!");
29640 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
29641 // debug statements here
29643 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
29645 export function RoutingFees_get_base_msat(this_ptr: number): number {
29646 if(!isWasmInitialized) {
29647 throw new Error("initializeWasm() must be awaited first!");
29649 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
29650 return nativeResponseValue;
29652 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
29654 export function RoutingFees_set_base_msat(this_ptr: number, val: number): void {
29655 if(!isWasmInitialized) {
29656 throw new Error("initializeWasm() must be awaited first!");
29658 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
29659 // debug statements here
29661 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
29663 export function RoutingFees_get_proportional_millionths(this_ptr: number): number {
29664 if(!isWasmInitialized) {
29665 throw new Error("initializeWasm() must be awaited first!");
29667 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
29668 return nativeResponseValue;
29670 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
29672 export function RoutingFees_set_proportional_millionths(this_ptr: number, val: number): void {
29673 if(!isWasmInitialized) {
29674 throw new Error("initializeWasm() must be awaited first!");
29676 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
29677 // debug statements here
29679 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
29681 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): number {
29682 if(!isWasmInitialized) {
29683 throw new Error("initializeWasm() must be awaited first!");
29685 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
29686 return nativeResponseValue;
29688 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
29690 export function RoutingFees_eq(a: number, b: number): boolean {
29691 if(!isWasmInitialized) {
29692 throw new Error("initializeWasm() must be awaited first!");
29694 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
29695 return nativeResponseValue;
29697 // uintptr_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
29699 export function RoutingFees_clone_ptr(arg: number): number {
29700 if(!isWasmInitialized) {
29701 throw new Error("initializeWasm() must be awaited first!");
29703 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
29704 return nativeResponseValue;
29706 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
29708 export function RoutingFees_clone(orig: number): number {
29709 if(!isWasmInitialized) {
29710 throw new Error("initializeWasm() must be awaited first!");
29712 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
29713 return nativeResponseValue;
29715 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
29717 export function RoutingFees_hash(o: number): bigint {
29718 if(!isWasmInitialized) {
29719 throw new Error("initializeWasm() must be awaited first!");
29721 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
29722 return nativeResponseValue;
29724 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
29726 export function RoutingFees_write(obj: number): number {
29727 if(!isWasmInitialized) {
29728 throw new Error("initializeWasm() must be awaited first!");
29730 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
29731 return nativeResponseValue;
29733 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
29735 export function RoutingFees_read(ser: number): number {
29736 if(!isWasmInitialized) {
29737 throw new Error("initializeWasm() must be awaited first!");
29739 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
29740 return nativeResponseValue;
29742 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
29744 export function NodeAnnouncementInfo_free(this_obj: number): void {
29745 if(!isWasmInitialized) {
29746 throw new Error("initializeWasm() must be awaited first!");
29748 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
29749 // debug statements here
29751 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29753 export function NodeAnnouncementInfo_get_features(this_ptr: number): number {
29754 if(!isWasmInitialized) {
29755 throw new Error("initializeWasm() must be awaited first!");
29757 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
29758 return nativeResponseValue;
29760 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
29762 export function NodeAnnouncementInfo_set_features(this_ptr: number, val: number): void {
29763 if(!isWasmInitialized) {
29764 throw new Error("initializeWasm() must be awaited first!");
29766 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
29767 // debug statements here
29769 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29771 export function NodeAnnouncementInfo_get_last_update(this_ptr: number): number {
29772 if(!isWasmInitialized) {
29773 throw new Error("initializeWasm() must be awaited first!");
29775 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
29776 return nativeResponseValue;
29778 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
29780 export function NodeAnnouncementInfo_set_last_update(this_ptr: number, val: number): void {
29781 if(!isWasmInitialized) {
29782 throw new Error("initializeWasm() must be awaited first!");
29784 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
29785 // debug statements here
29787 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
29789 export function NodeAnnouncementInfo_get_rgb(this_ptr: number): number {
29790 if(!isWasmInitialized) {
29791 throw new Error("initializeWasm() must be awaited first!");
29793 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
29794 return nativeResponseValue;
29796 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
29798 export function NodeAnnouncementInfo_set_rgb(this_ptr: number, val: number): void {
29799 if(!isWasmInitialized) {
29800 throw new Error("initializeWasm() must be awaited first!");
29802 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
29803 // debug statements here
29805 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29807 export function NodeAnnouncementInfo_get_alias(this_ptr: number): number {
29808 if(!isWasmInitialized) {
29809 throw new Error("initializeWasm() must be awaited first!");
29811 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
29812 return nativeResponseValue;
29814 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
29816 export function NodeAnnouncementInfo_set_alias(this_ptr: number, val: number): void {
29817 if(!isWasmInitialized) {
29818 throw new Error("initializeWasm() must be awaited first!");
29820 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
29821 // debug statements here
29823 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
29825 export function NodeAnnouncementInfo_set_addresses(this_ptr: number, val: number): void {
29826 if(!isWasmInitialized) {
29827 throw new Error("initializeWasm() must be awaited first!");
29829 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
29830 // debug statements here
29832 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29834 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: number): number {
29835 if(!isWasmInitialized) {
29836 throw new Error("initializeWasm() must be awaited first!");
29838 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
29839 return nativeResponseValue;
29841 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
29843 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: number, val: number): void {
29844 if(!isWasmInitialized) {
29845 throw new Error("initializeWasm() must be awaited first!");
29847 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
29848 // debug statements here
29850 // 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);
29852 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 {
29853 if(!isWasmInitialized) {
29854 throw new Error("initializeWasm() must be awaited first!");
29856 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
29857 return nativeResponseValue;
29859 // uintptr_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
29861 export function NodeAnnouncementInfo_clone_ptr(arg: number): number {
29862 if(!isWasmInitialized) {
29863 throw new Error("initializeWasm() must be awaited first!");
29865 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
29866 return nativeResponseValue;
29868 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
29870 export function NodeAnnouncementInfo_clone(orig: number): number {
29871 if(!isWasmInitialized) {
29872 throw new Error("initializeWasm() must be awaited first!");
29874 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
29875 return nativeResponseValue;
29877 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
29879 export function NodeAnnouncementInfo_write(obj: number): number {
29880 if(!isWasmInitialized) {
29881 throw new Error("initializeWasm() must be awaited first!");
29883 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
29884 return nativeResponseValue;
29886 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
29888 export function NodeAnnouncementInfo_read(ser: number): number {
29889 if(!isWasmInitialized) {
29890 throw new Error("initializeWasm() must be awaited first!");
29892 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
29893 return nativeResponseValue;
29895 // void NodeAlias_free(struct LDKNodeAlias this_obj);
29897 export function NodeAlias_free(this_obj: number): void {
29898 if(!isWasmInitialized) {
29899 throw new Error("initializeWasm() must be awaited first!");
29901 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
29902 // debug statements here
29904 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
29906 export function NodeAlias_get_a(this_ptr: number): number {
29907 if(!isWasmInitialized) {
29908 throw new Error("initializeWasm() must be awaited first!");
29910 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
29911 return nativeResponseValue;
29913 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29915 export function NodeAlias_set_a(this_ptr: number, val: number): void {
29916 if(!isWasmInitialized) {
29917 throw new Error("initializeWasm() must be awaited first!");
29919 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
29920 // debug statements here
29922 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
29924 export function NodeAlias_new(a_arg: number): number {
29925 if(!isWasmInitialized) {
29926 throw new Error("initializeWasm() must be awaited first!");
29928 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
29929 return nativeResponseValue;
29931 // uintptr_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
29933 export function NodeAlias_clone_ptr(arg: number): number {
29934 if(!isWasmInitialized) {
29935 throw new Error("initializeWasm() must be awaited first!");
29937 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
29938 return nativeResponseValue;
29940 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
29942 export function NodeAlias_clone(orig: number): number {
29943 if(!isWasmInitialized) {
29944 throw new Error("initializeWasm() must be awaited first!");
29946 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
29947 return nativeResponseValue;
29949 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
29951 export function NodeAlias_write(obj: number): number {
29952 if(!isWasmInitialized) {
29953 throw new Error("initializeWasm() must be awaited first!");
29955 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
29956 return nativeResponseValue;
29958 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
29960 export function NodeAlias_read(ser: number): number {
29961 if(!isWasmInitialized) {
29962 throw new Error("initializeWasm() must be awaited first!");
29964 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
29965 return nativeResponseValue;
29967 // void NodeInfo_free(struct LDKNodeInfo this_obj);
29969 export function NodeInfo_free(this_obj: number): void {
29970 if(!isWasmInitialized) {
29971 throw new Error("initializeWasm() must be awaited first!");
29973 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
29974 // debug statements here
29976 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
29978 export function NodeInfo_set_channels(this_ptr: number, val: number): void {
29979 if(!isWasmInitialized) {
29980 throw new Error("initializeWasm() must be awaited first!");
29982 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
29983 // debug statements here
29985 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
29987 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: number): number {
29988 if(!isWasmInitialized) {
29989 throw new Error("initializeWasm() must be awaited first!");
29991 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
29992 return nativeResponseValue;
29994 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
29996 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: number, val: number): void {
29997 if(!isWasmInitialized) {
29998 throw new Error("initializeWasm() must be awaited first!");
30000 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
30001 // debug statements here
30003 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
30005 export function NodeInfo_get_announcement_info(this_ptr: number): number {
30006 if(!isWasmInitialized) {
30007 throw new Error("initializeWasm() must be awaited first!");
30009 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
30010 return nativeResponseValue;
30012 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
30014 export function NodeInfo_set_announcement_info(this_ptr: number, val: number): void {
30015 if(!isWasmInitialized) {
30016 throw new Error("initializeWasm() must be awaited first!");
30018 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
30019 // debug statements here
30021 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
30023 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: number, announcement_info_arg: number): number {
30024 if(!isWasmInitialized) {
30025 throw new Error("initializeWasm() must be awaited first!");
30027 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
30028 return nativeResponseValue;
30030 // uintptr_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
30032 export function NodeInfo_clone_ptr(arg: number): number {
30033 if(!isWasmInitialized) {
30034 throw new Error("initializeWasm() must be awaited first!");
30036 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
30037 return nativeResponseValue;
30039 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
30041 export function NodeInfo_clone(orig: number): number {
30042 if(!isWasmInitialized) {
30043 throw new Error("initializeWasm() must be awaited first!");
30045 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
30046 return nativeResponseValue;
30048 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
30050 export function NodeInfo_write(obj: number): number {
30051 if(!isWasmInitialized) {
30052 throw new Error("initializeWasm() must be awaited first!");
30054 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
30055 return nativeResponseValue;
30057 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
30059 export function NodeInfo_read(ser: number): number {
30060 if(!isWasmInitialized) {
30061 throw new Error("initializeWasm() must be awaited first!");
30063 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
30064 return nativeResponseValue;
30066 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
30068 export function NetworkGraph_write(obj: number): number {
30069 if(!isWasmInitialized) {
30070 throw new Error("initializeWasm() must be awaited first!");
30072 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
30073 return nativeResponseValue;
30075 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
30077 export function NetworkGraph_read(ser: number, arg: number): number {
30078 if(!isWasmInitialized) {
30079 throw new Error("initializeWasm() must be awaited first!");
30081 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
30082 return nativeResponseValue;
30084 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKLogger logger);
30086 export function NetworkGraph_new(genesis_hash: number, logger: number): number {
30087 if(!isWasmInitialized) {
30088 throw new Error("initializeWasm() must be awaited first!");
30090 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash, logger);
30091 return nativeResponseValue;
30093 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
30095 export function NetworkGraph_read_only(this_arg: number): number {
30096 if(!isWasmInitialized) {
30097 throw new Error("initializeWasm() must be awaited first!");
30099 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
30100 return nativeResponseValue;
30102 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
30104 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: number): number {
30105 if(!isWasmInitialized) {
30106 throw new Error("initializeWasm() must be awaited first!");
30108 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
30109 return nativeResponseValue;
30111 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
30113 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: number, last_rapid_gossip_sync_timestamp: number): void {
30114 if(!isWasmInitialized) {
30115 throw new Error("initializeWasm() must be awaited first!");
30117 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
30118 // debug statements here
30120 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
30122 export function NetworkGraph_update_node_from_announcement(this_arg: number, msg: number): number {
30123 if(!isWasmInitialized) {
30124 throw new Error("initializeWasm() must be awaited first!");
30126 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
30127 return nativeResponseValue;
30129 // 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);
30131 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: number, msg: number): number {
30132 if(!isWasmInitialized) {
30133 throw new Error("initializeWasm() must be awaited first!");
30135 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
30136 return nativeResponseValue;
30138 // 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);
30140 export function NetworkGraph_update_channel_from_announcement(this_arg: number, msg: number, chain_access: number): number {
30141 if(!isWasmInitialized) {
30142 throw new Error("initializeWasm() must be awaited first!");
30144 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
30145 return nativeResponseValue;
30147 // 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);
30149 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: number, msg: number, chain_access: number): number {
30150 if(!isWasmInitialized) {
30151 throw new Error("initializeWasm() must be awaited first!");
30153 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
30154 return nativeResponseValue;
30156 // 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);
30158 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 {
30159 if(!isWasmInitialized) {
30160 throw new Error("initializeWasm() must be awaited first!");
30162 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
30163 return nativeResponseValue;
30165 // void NetworkGraph_channel_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
30167 export function NetworkGraph_channel_failed(this_arg: number, short_channel_id: bigint, is_permanent: boolean): void {
30168 if(!isWasmInitialized) {
30169 throw new Error("initializeWasm() must be awaited first!");
30171 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed(this_arg, short_channel_id, is_permanent);
30172 // debug statements here
30174 // void NetworkGraph_node_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
30176 export function NetworkGraph_node_failed(this_arg: number, _node_id: number, is_permanent: boolean): void {
30177 if(!isWasmInitialized) {
30178 throw new Error("initializeWasm() must be awaited first!");
30180 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed(this_arg, _node_id, is_permanent);
30181 // debug statements here
30183 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
30185 export function NetworkGraph_remove_stale_channels_with_time(this_arg: number, current_time_unix: bigint): void {
30186 if(!isWasmInitialized) {
30187 throw new Error("initializeWasm() must be awaited first!");
30189 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
30190 // debug statements here
30192 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
30194 export function NetworkGraph_update_channel(this_arg: number, msg: number): number {
30195 if(!isWasmInitialized) {
30196 throw new Error("initializeWasm() must be awaited first!");
30198 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
30199 return nativeResponseValue;
30201 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
30203 export function NetworkGraph_update_channel_unsigned(this_arg: number, msg: number): number {
30204 if(!isWasmInitialized) {
30205 throw new Error("initializeWasm() must be awaited first!");
30207 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
30208 return nativeResponseValue;
30210 // MUST_USE_RES struct LDKChannelInfo ReadOnlyNetworkGraph_channel(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id);
30212 export function ReadOnlyNetworkGraph_channel(this_arg: number, short_channel_id: bigint): number {
30213 if(!isWasmInitialized) {
30214 throw new Error("initializeWasm() must be awaited first!");
30216 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_channel(this_arg, short_channel_id);
30217 return nativeResponseValue;
30219 // MUST_USE_RES struct LDKNodeInfo ReadOnlyNetworkGraph_node(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
30221 export function ReadOnlyNetworkGraph_node(this_arg: number, node_id: number): number {
30222 if(!isWasmInitialized) {
30223 throw new Error("initializeWasm() must be awaited first!");
30225 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_node(this_arg, node_id);
30226 return nativeResponseValue;
30228 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
30230 export function ReadOnlyNetworkGraph_get_addresses(this_arg: number, pubkey: number): number {
30231 if(!isWasmInitialized) {
30232 throw new Error("initializeWasm() must be awaited first!");
30234 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
30235 return nativeResponseValue;
30237 // void RouteHop_free(struct LDKRouteHop this_obj);
30239 export function RouteHop_free(this_obj: number): void {
30240 if(!isWasmInitialized) {
30241 throw new Error("initializeWasm() must be awaited first!");
30243 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
30244 // debug statements here
30246 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30248 export function RouteHop_get_pubkey(this_ptr: number): number {
30249 if(!isWasmInitialized) {
30250 throw new Error("initializeWasm() must be awaited first!");
30252 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
30253 return nativeResponseValue;
30255 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30257 export function RouteHop_set_pubkey(this_ptr: number, val: number): void {
30258 if(!isWasmInitialized) {
30259 throw new Error("initializeWasm() must be awaited first!");
30261 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
30262 // debug statements here
30264 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30266 export function RouteHop_get_node_features(this_ptr: number): number {
30267 if(!isWasmInitialized) {
30268 throw new Error("initializeWasm() must be awaited first!");
30270 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
30271 return nativeResponseValue;
30273 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
30275 export function RouteHop_set_node_features(this_ptr: number, val: number): void {
30276 if(!isWasmInitialized) {
30277 throw new Error("initializeWasm() must be awaited first!");
30279 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
30280 // debug statements here
30282 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30284 export function RouteHop_get_short_channel_id(this_ptr: number): bigint {
30285 if(!isWasmInitialized) {
30286 throw new Error("initializeWasm() must be awaited first!");
30288 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
30289 return nativeResponseValue;
30291 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
30293 export function RouteHop_set_short_channel_id(this_ptr: number, val: bigint): void {
30294 if(!isWasmInitialized) {
30295 throw new Error("initializeWasm() must be awaited first!");
30297 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
30298 // debug statements here
30300 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30302 export function RouteHop_get_channel_features(this_ptr: number): number {
30303 if(!isWasmInitialized) {
30304 throw new Error("initializeWasm() must be awaited first!");
30306 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
30307 return nativeResponseValue;
30309 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
30311 export function RouteHop_set_channel_features(this_ptr: number, val: number): void {
30312 if(!isWasmInitialized) {
30313 throw new Error("initializeWasm() must be awaited first!");
30315 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
30316 // debug statements here
30318 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30320 export function RouteHop_get_fee_msat(this_ptr: number): bigint {
30321 if(!isWasmInitialized) {
30322 throw new Error("initializeWasm() must be awaited first!");
30324 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
30325 return nativeResponseValue;
30327 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
30329 export function RouteHop_set_fee_msat(this_ptr: number, val: bigint): void {
30330 if(!isWasmInitialized) {
30331 throw new Error("initializeWasm() must be awaited first!");
30333 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
30334 // debug statements here
30336 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
30338 export function RouteHop_get_cltv_expiry_delta(this_ptr: number): number {
30339 if(!isWasmInitialized) {
30340 throw new Error("initializeWasm() must be awaited first!");
30342 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
30343 return nativeResponseValue;
30345 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
30347 export function RouteHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
30348 if(!isWasmInitialized) {
30349 throw new Error("initializeWasm() must be awaited first!");
30351 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
30352 // debug statements here
30354 // 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);
30356 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 {
30357 if(!isWasmInitialized) {
30358 throw new Error("initializeWasm() must be awaited first!");
30360 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);
30361 return nativeResponseValue;
30363 // uintptr_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
30365 export function RouteHop_clone_ptr(arg: number): number {
30366 if(!isWasmInitialized) {
30367 throw new Error("initializeWasm() must be awaited first!");
30369 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
30370 return nativeResponseValue;
30372 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
30374 export function RouteHop_clone(orig: number): number {
30375 if(!isWasmInitialized) {
30376 throw new Error("initializeWasm() must be awaited first!");
30378 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
30379 return nativeResponseValue;
30381 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
30383 export function RouteHop_hash(o: number): bigint {
30384 if(!isWasmInitialized) {
30385 throw new Error("initializeWasm() must be awaited first!");
30387 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
30388 return nativeResponseValue;
30390 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
30392 export function RouteHop_eq(a: number, b: number): boolean {
30393 if(!isWasmInitialized) {
30394 throw new Error("initializeWasm() must be awaited first!");
30396 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
30397 return nativeResponseValue;
30399 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
30401 export function RouteHop_write(obj: number): number {
30402 if(!isWasmInitialized) {
30403 throw new Error("initializeWasm() must be awaited first!");
30405 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
30406 return nativeResponseValue;
30408 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
30410 export function RouteHop_read(ser: number): number {
30411 if(!isWasmInitialized) {
30412 throw new Error("initializeWasm() must be awaited first!");
30414 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
30415 return nativeResponseValue;
30417 // void Route_free(struct LDKRoute this_obj);
30419 export function Route_free(this_obj: number): void {
30420 if(!isWasmInitialized) {
30421 throw new Error("initializeWasm() must be awaited first!");
30423 const nativeResponseValue = wasm.TS_Route_free(this_obj);
30424 // debug statements here
30426 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
30428 export function Route_get_paths(this_ptr: number): number {
30429 if(!isWasmInitialized) {
30430 throw new Error("initializeWasm() must be awaited first!");
30432 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
30433 return nativeResponseValue;
30435 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
30437 export function Route_set_paths(this_ptr: number, val: number): void {
30438 if(!isWasmInitialized) {
30439 throw new Error("initializeWasm() must be awaited first!");
30441 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
30442 // debug statements here
30444 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
30446 export function Route_get_payment_params(this_ptr: number): number {
30447 if(!isWasmInitialized) {
30448 throw new Error("initializeWasm() must be awaited first!");
30450 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
30451 return nativeResponseValue;
30453 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
30455 export function Route_set_payment_params(this_ptr: number, val: number): void {
30456 if(!isWasmInitialized) {
30457 throw new Error("initializeWasm() must be awaited first!");
30459 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
30460 // debug statements here
30462 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
30464 export function Route_new(paths_arg: number, payment_params_arg: number): number {
30465 if(!isWasmInitialized) {
30466 throw new Error("initializeWasm() must be awaited first!");
30468 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
30469 return nativeResponseValue;
30471 // uintptr_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
30473 export function Route_clone_ptr(arg: number): number {
30474 if(!isWasmInitialized) {
30475 throw new Error("initializeWasm() must be awaited first!");
30477 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
30478 return nativeResponseValue;
30480 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
30482 export function Route_clone(orig: number): number {
30483 if(!isWasmInitialized) {
30484 throw new Error("initializeWasm() must be awaited first!");
30486 const nativeResponseValue = wasm.TS_Route_clone(orig);
30487 return nativeResponseValue;
30489 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
30491 export function Route_hash(o: number): bigint {
30492 if(!isWasmInitialized) {
30493 throw new Error("initializeWasm() must be awaited first!");
30495 const nativeResponseValue = wasm.TS_Route_hash(o);
30496 return nativeResponseValue;
30498 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
30500 export function Route_eq(a: number, b: number): boolean {
30501 if(!isWasmInitialized) {
30502 throw new Error("initializeWasm() must be awaited first!");
30504 const nativeResponseValue = wasm.TS_Route_eq(a, b);
30505 return nativeResponseValue;
30507 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
30509 export function Route_get_total_fees(this_arg: number): bigint {
30510 if(!isWasmInitialized) {
30511 throw new Error("initializeWasm() must be awaited first!");
30513 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
30514 return nativeResponseValue;
30516 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
30518 export function Route_get_total_amount(this_arg: number): bigint {
30519 if(!isWasmInitialized) {
30520 throw new Error("initializeWasm() must be awaited first!");
30522 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
30523 return nativeResponseValue;
30525 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
30527 export function Route_write(obj: number): number {
30528 if(!isWasmInitialized) {
30529 throw new Error("initializeWasm() must be awaited first!");
30531 const nativeResponseValue = wasm.TS_Route_write(obj);
30532 return nativeResponseValue;
30534 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
30536 export function Route_read(ser: number): number {
30537 if(!isWasmInitialized) {
30538 throw new Error("initializeWasm() must be awaited first!");
30540 const nativeResponseValue = wasm.TS_Route_read(ser);
30541 return nativeResponseValue;
30543 // void RouteParameters_free(struct LDKRouteParameters this_obj);
30545 export function RouteParameters_free(this_obj: number): void {
30546 if(!isWasmInitialized) {
30547 throw new Error("initializeWasm() must be awaited first!");
30549 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
30550 // debug statements here
30552 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30554 export function RouteParameters_get_payment_params(this_ptr: number): number {
30555 if(!isWasmInitialized) {
30556 throw new Error("initializeWasm() must be awaited first!");
30558 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
30559 return nativeResponseValue;
30561 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
30563 export function RouteParameters_set_payment_params(this_ptr: number, val: number): void {
30564 if(!isWasmInitialized) {
30565 throw new Error("initializeWasm() must be awaited first!");
30567 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
30568 // debug statements here
30570 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30572 export function RouteParameters_get_final_value_msat(this_ptr: number): bigint {
30573 if(!isWasmInitialized) {
30574 throw new Error("initializeWasm() must be awaited first!");
30576 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
30577 return nativeResponseValue;
30579 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
30581 export function RouteParameters_set_final_value_msat(this_ptr: number, val: bigint): void {
30582 if(!isWasmInitialized) {
30583 throw new Error("initializeWasm() must be awaited first!");
30585 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
30586 // debug statements here
30588 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30590 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: number): number {
30591 if(!isWasmInitialized) {
30592 throw new Error("initializeWasm() must be awaited first!");
30594 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
30595 return nativeResponseValue;
30597 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
30599 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: number, val: number): void {
30600 if(!isWasmInitialized) {
30601 throw new Error("initializeWasm() must be awaited first!");
30603 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
30604 // debug statements here
30606 // 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);
30608 export function RouteParameters_new(payment_params_arg: number, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): number {
30609 if(!isWasmInitialized) {
30610 throw new Error("initializeWasm() must be awaited first!");
30612 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
30613 return nativeResponseValue;
30615 // uintptr_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
30617 export function RouteParameters_clone_ptr(arg: number): number {
30618 if(!isWasmInitialized) {
30619 throw new Error("initializeWasm() must be awaited first!");
30621 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
30622 return nativeResponseValue;
30624 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
30626 export function RouteParameters_clone(orig: number): number {
30627 if(!isWasmInitialized) {
30628 throw new Error("initializeWasm() must be awaited first!");
30630 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
30631 return nativeResponseValue;
30633 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
30635 export function RouteParameters_write(obj: number): number {
30636 if(!isWasmInitialized) {
30637 throw new Error("initializeWasm() must be awaited first!");
30639 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
30640 return nativeResponseValue;
30642 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
30644 export function RouteParameters_read(ser: number): number {
30645 if(!isWasmInitialized) {
30646 throw new Error("initializeWasm() must be awaited first!");
30648 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
30649 return nativeResponseValue;
30651 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
30653 export function PaymentParameters_free(this_obj: number): void {
30654 if(!isWasmInitialized) {
30655 throw new Error("initializeWasm() must be awaited first!");
30657 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
30658 // debug statements here
30660 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30662 export function PaymentParameters_get_payee_pubkey(this_ptr: number): number {
30663 if(!isWasmInitialized) {
30664 throw new Error("initializeWasm() must be awaited first!");
30666 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
30667 return nativeResponseValue;
30669 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30671 export function PaymentParameters_set_payee_pubkey(this_ptr: number, val: number): void {
30672 if(!isWasmInitialized) {
30673 throw new Error("initializeWasm() must be awaited first!");
30675 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
30676 // debug statements here
30678 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30680 export function PaymentParameters_get_features(this_ptr: number): number {
30681 if(!isWasmInitialized) {
30682 throw new Error("initializeWasm() must be awaited first!");
30684 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
30685 return nativeResponseValue;
30687 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
30689 export function PaymentParameters_set_features(this_ptr: number, val: number): void {
30690 if(!isWasmInitialized) {
30691 throw new Error("initializeWasm() must be awaited first!");
30693 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
30694 // debug statements here
30696 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30698 export function PaymentParameters_get_route_hints(this_ptr: number): number {
30699 if(!isWasmInitialized) {
30700 throw new Error("initializeWasm() must be awaited first!");
30702 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
30703 return nativeResponseValue;
30705 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
30707 export function PaymentParameters_set_route_hints(this_ptr: number, val: number): void {
30708 if(!isWasmInitialized) {
30709 throw new Error("initializeWasm() must be awaited first!");
30711 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
30712 // debug statements here
30714 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30716 export function PaymentParameters_get_expiry_time(this_ptr: number): number {
30717 if(!isWasmInitialized) {
30718 throw new Error("initializeWasm() must be awaited first!");
30720 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
30721 return nativeResponseValue;
30723 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30725 export function PaymentParameters_set_expiry_time(this_ptr: number, val: number): void {
30726 if(!isWasmInitialized) {
30727 throw new Error("initializeWasm() must be awaited first!");
30729 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
30730 // debug statements here
30732 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30734 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: number): number {
30735 if(!isWasmInitialized) {
30736 throw new Error("initializeWasm() must be awaited first!");
30738 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
30739 return nativeResponseValue;
30741 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
30743 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: number, val: number): void {
30744 if(!isWasmInitialized) {
30745 throw new Error("initializeWasm() must be awaited first!");
30747 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
30748 // debug statements here
30750 // uint8_t PaymentParameters_get_max_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30752 export function PaymentParameters_get_max_path_count(this_ptr: number): number {
30753 if(!isWasmInitialized) {
30754 throw new Error("initializeWasm() must be awaited first!");
30756 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_path_count(this_ptr);
30757 return nativeResponseValue;
30759 // void PaymentParameters_set_max_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
30761 export function PaymentParameters_set_max_path_count(this_ptr: number, val: number): void {
30762 if(!isWasmInitialized) {
30763 throw new Error("initializeWasm() must be awaited first!");
30765 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_path_count(this_ptr, val);
30766 // debug statements here
30768 // uint8_t PaymentParameters_get_max_channel_saturation_power_of_half(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30770 export function PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr: number): number {
30771 if(!isWasmInitialized) {
30772 throw new Error("initializeWasm() must be awaited first!");
30774 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_channel_saturation_power_of_half(this_ptr);
30775 return nativeResponseValue;
30777 // void PaymentParameters_set_max_channel_saturation_power_of_half(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
30779 export function PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr: number, val: number): void {
30780 if(!isWasmInitialized) {
30781 throw new Error("initializeWasm() must be awaited first!");
30783 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_channel_saturation_power_of_half(this_ptr, val);
30784 // debug statements here
30786 // void PaymentParameters_set_previously_failed_channels(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
30788 export function PaymentParameters_set_previously_failed_channels(this_ptr: number, val: number): void {
30789 if(!isWasmInitialized) {
30790 throw new Error("initializeWasm() must be awaited first!");
30792 const nativeResponseValue = wasm.TS_PaymentParameters_set_previously_failed_channels(this_ptr, val);
30793 // debug statements here
30795 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_new(struct LDKPublicKey payee_pubkey_arg, struct LDKInvoiceFeatures features_arg, struct LDKCVec_RouteHintZ route_hints_arg, struct LDKCOption_u64Z expiry_time_arg, uint32_t max_total_cltv_expiry_delta_arg, uint8_t max_path_count_arg, uint8_t max_channel_saturation_power_of_half_arg, struct LDKCVec_u64Z previously_failed_channels_arg);
30797 export function PaymentParameters_new(payee_pubkey_arg: number, features_arg: number, route_hints_arg: number, expiry_time_arg: number, max_total_cltv_expiry_delta_arg: number, max_path_count_arg: number, max_channel_saturation_power_of_half_arg: number, previously_failed_channels_arg: number): number {
30798 if(!isWasmInitialized) {
30799 throw new Error("initializeWasm() must be awaited first!");
30801 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg, max_path_count_arg, max_channel_saturation_power_of_half_arg, previously_failed_channels_arg);
30802 return nativeResponseValue;
30804 // uintptr_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
30806 export function PaymentParameters_clone_ptr(arg: number): number {
30807 if(!isWasmInitialized) {
30808 throw new Error("initializeWasm() must be awaited first!");
30810 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
30811 return nativeResponseValue;
30813 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
30815 export function PaymentParameters_clone(orig: number): number {
30816 if(!isWasmInitialized) {
30817 throw new Error("initializeWasm() must be awaited first!");
30819 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
30820 return nativeResponseValue;
30822 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
30824 export function PaymentParameters_hash(o: number): bigint {
30825 if(!isWasmInitialized) {
30826 throw new Error("initializeWasm() must be awaited first!");
30828 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
30829 return nativeResponseValue;
30831 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
30833 export function PaymentParameters_eq(a: number, b: number): boolean {
30834 if(!isWasmInitialized) {
30835 throw new Error("initializeWasm() must be awaited first!");
30837 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
30838 return nativeResponseValue;
30840 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
30842 export function PaymentParameters_write(obj: number): number {
30843 if(!isWasmInitialized) {
30844 throw new Error("initializeWasm() must be awaited first!");
30846 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
30847 return nativeResponseValue;
30849 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
30851 export function PaymentParameters_read(ser: number): number {
30852 if(!isWasmInitialized) {
30853 throw new Error("initializeWasm() must be awaited first!");
30855 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
30856 return nativeResponseValue;
30858 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
30860 export function PaymentParameters_from_node_id(payee_pubkey: number): number {
30861 if(!isWasmInitialized) {
30862 throw new Error("initializeWasm() must be awaited first!");
30864 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
30865 return nativeResponseValue;
30867 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
30869 export function PaymentParameters_for_keysend(payee_pubkey: number): number {
30870 if(!isWasmInitialized) {
30871 throw new Error("initializeWasm() must be awaited first!");
30873 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
30874 return nativeResponseValue;
30876 // void RouteHint_free(struct LDKRouteHint this_obj);
30878 export function RouteHint_free(this_obj: number): void {
30879 if(!isWasmInitialized) {
30880 throw new Error("initializeWasm() must be awaited first!");
30882 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
30883 // debug statements here
30885 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
30887 export function RouteHint_get_a(this_ptr: number): number {
30888 if(!isWasmInitialized) {
30889 throw new Error("initializeWasm() must be awaited first!");
30891 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
30892 return nativeResponseValue;
30894 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
30896 export function RouteHint_set_a(this_ptr: number, val: number): void {
30897 if(!isWasmInitialized) {
30898 throw new Error("initializeWasm() must be awaited first!");
30900 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
30901 // debug statements here
30903 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
30905 export function RouteHint_new(a_arg: number): number {
30906 if(!isWasmInitialized) {
30907 throw new Error("initializeWasm() must be awaited first!");
30909 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
30910 return nativeResponseValue;
30912 // uintptr_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
30914 export function RouteHint_clone_ptr(arg: number): number {
30915 if(!isWasmInitialized) {
30916 throw new Error("initializeWasm() must be awaited first!");
30918 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
30919 return nativeResponseValue;
30921 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
30923 export function RouteHint_clone(orig: number): number {
30924 if(!isWasmInitialized) {
30925 throw new Error("initializeWasm() must be awaited first!");
30927 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
30928 return nativeResponseValue;
30930 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
30932 export function RouteHint_hash(o: number): bigint {
30933 if(!isWasmInitialized) {
30934 throw new Error("initializeWasm() must be awaited first!");
30936 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
30937 return nativeResponseValue;
30939 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
30941 export function RouteHint_eq(a: number, b: number): boolean {
30942 if(!isWasmInitialized) {
30943 throw new Error("initializeWasm() must be awaited first!");
30945 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
30946 return nativeResponseValue;
30948 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
30950 export function RouteHint_write(obj: number): number {
30951 if(!isWasmInitialized) {
30952 throw new Error("initializeWasm() must be awaited first!");
30954 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
30955 return nativeResponseValue;
30957 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
30959 export function RouteHint_read(ser: number): number {
30960 if(!isWasmInitialized) {
30961 throw new Error("initializeWasm() must be awaited first!");
30963 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
30964 return nativeResponseValue;
30966 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
30968 export function RouteHintHop_free(this_obj: number): void {
30969 if(!isWasmInitialized) {
30970 throw new Error("initializeWasm() must be awaited first!");
30972 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
30973 // debug statements here
30975 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30977 export function RouteHintHop_get_src_node_id(this_ptr: number): number {
30978 if(!isWasmInitialized) {
30979 throw new Error("initializeWasm() must be awaited first!");
30981 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
30982 return nativeResponseValue;
30984 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30986 export function RouteHintHop_set_src_node_id(this_ptr: number, val: number): void {
30987 if(!isWasmInitialized) {
30988 throw new Error("initializeWasm() must be awaited first!");
30990 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
30991 // debug statements here
30993 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30995 export function RouteHintHop_get_short_channel_id(this_ptr: number): bigint {
30996 if(!isWasmInitialized) {
30997 throw new Error("initializeWasm() must be awaited first!");
30999 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
31000 return nativeResponseValue;
31002 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
31004 export function RouteHintHop_set_short_channel_id(this_ptr: number, val: bigint): void {
31005 if(!isWasmInitialized) {
31006 throw new Error("initializeWasm() must be awaited first!");
31008 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
31009 // debug statements here
31011 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31013 export function RouteHintHop_get_fees(this_ptr: number): number {
31014 if(!isWasmInitialized) {
31015 throw new Error("initializeWasm() must be awaited first!");
31017 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
31018 return nativeResponseValue;
31020 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
31022 export function RouteHintHop_set_fees(this_ptr: number, val: number): void {
31023 if(!isWasmInitialized) {
31024 throw new Error("initializeWasm() must be awaited first!");
31026 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
31027 // debug statements here
31029 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31031 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: number): number {
31032 if(!isWasmInitialized) {
31033 throw new Error("initializeWasm() must be awaited first!");
31035 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
31036 return nativeResponseValue;
31038 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
31040 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
31041 if(!isWasmInitialized) {
31042 throw new Error("initializeWasm() must be awaited first!");
31044 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
31045 // debug statements here
31047 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31049 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: number): number {
31050 if(!isWasmInitialized) {
31051 throw new Error("initializeWasm() must be awaited first!");
31053 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
31054 return nativeResponseValue;
31056 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
31058 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: number, val: number): void {
31059 if(!isWasmInitialized) {
31060 throw new Error("initializeWasm() must be awaited first!");
31062 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
31063 // debug statements here
31065 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
31067 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: number): number {
31068 if(!isWasmInitialized) {
31069 throw new Error("initializeWasm() must be awaited first!");
31071 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
31072 return nativeResponseValue;
31074 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
31076 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: number, val: number): void {
31077 if(!isWasmInitialized) {
31078 throw new Error("initializeWasm() must be awaited first!");
31080 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
31081 // debug statements here
31083 // 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);
31085 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 {
31086 if(!isWasmInitialized) {
31087 throw new Error("initializeWasm() must be awaited first!");
31089 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);
31090 return nativeResponseValue;
31092 // uintptr_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
31094 export function RouteHintHop_clone_ptr(arg: number): number {
31095 if(!isWasmInitialized) {
31096 throw new Error("initializeWasm() must be awaited first!");
31098 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
31099 return nativeResponseValue;
31101 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
31103 export function RouteHintHop_clone(orig: number): number {
31104 if(!isWasmInitialized) {
31105 throw new Error("initializeWasm() must be awaited first!");
31107 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
31108 return nativeResponseValue;
31110 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
31112 export function RouteHintHop_hash(o: number): bigint {
31113 if(!isWasmInitialized) {
31114 throw new Error("initializeWasm() must be awaited first!");
31116 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
31117 return nativeResponseValue;
31119 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
31121 export function RouteHintHop_eq(a: number, b: number): boolean {
31122 if(!isWasmInitialized) {
31123 throw new Error("initializeWasm() must be awaited first!");
31125 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
31126 return nativeResponseValue;
31128 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
31130 export function RouteHintHop_write(obj: number): number {
31131 if(!isWasmInitialized) {
31132 throw new Error("initializeWasm() must be awaited first!");
31134 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
31135 return nativeResponseValue;
31137 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
31139 export function RouteHintHop_read(ser: number): number {
31140 if(!isWasmInitialized) {
31141 throw new Error("initializeWasm() must be awaited first!");
31143 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
31144 return nativeResponseValue;
31146 // 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]);
31148 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 {
31149 if(!isWasmInitialized) {
31150 throw new Error("initializeWasm() must be awaited first!");
31152 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
31153 return nativeResponseValue;
31155 // 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]);
31157 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 {
31158 if(!isWasmInitialized) {
31159 throw new Error("initializeWasm() must be awaited first!");
31161 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
31162 return nativeResponseValue;
31164 // void Score_free(struct LDKScore this_ptr);
31166 export function Score_free(this_ptr: number): void {
31167 if(!isWasmInitialized) {
31168 throw new Error("initializeWasm() must be awaited first!");
31170 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
31171 // debug statements here
31173 // void LockableScore_free(struct LDKLockableScore this_ptr);
31175 export function LockableScore_free(this_ptr: number): void {
31176 if(!isWasmInitialized) {
31177 throw new Error("initializeWasm() must be awaited first!");
31179 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
31180 // debug statements here
31182 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
31184 export function MultiThreadedLockableScore_free(this_obj: number): void {
31185 if(!isWasmInitialized) {
31186 throw new Error("initializeWasm() must be awaited first!");
31188 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
31189 // debug statements here
31191 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
31193 export function MultiThreadedLockableScore_write(obj: number): number {
31194 if(!isWasmInitialized) {
31195 throw new Error("initializeWasm() must be awaited first!");
31197 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
31198 return nativeResponseValue;
31200 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
31202 export function MultiThreadedLockableScore_new(score: number): number {
31203 if(!isWasmInitialized) {
31204 throw new Error("initializeWasm() must be awaited first!");
31206 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
31207 return nativeResponseValue;
31209 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
31211 export function ChannelUsage_free(this_obj: number): void {
31212 if(!isWasmInitialized) {
31213 throw new Error("initializeWasm() must be awaited first!");
31215 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
31216 // debug statements here
31218 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
31220 export function ChannelUsage_get_amount_msat(this_ptr: number): bigint {
31221 if(!isWasmInitialized) {
31222 throw new Error("initializeWasm() must be awaited first!");
31224 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
31225 return nativeResponseValue;
31227 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
31229 export function ChannelUsage_set_amount_msat(this_ptr: number, val: bigint): void {
31230 if(!isWasmInitialized) {
31231 throw new Error("initializeWasm() must be awaited first!");
31233 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
31234 // debug statements here
31236 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
31238 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: number): bigint {
31239 if(!isWasmInitialized) {
31240 throw new Error("initializeWasm() must be awaited first!");
31242 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
31243 return nativeResponseValue;
31245 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
31247 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: number, val: bigint): void {
31248 if(!isWasmInitialized) {
31249 throw new Error("initializeWasm() must be awaited first!");
31251 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
31252 // debug statements here
31254 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
31256 export function ChannelUsage_get_effective_capacity(this_ptr: number): number {
31257 if(!isWasmInitialized) {
31258 throw new Error("initializeWasm() must be awaited first!");
31260 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
31261 return nativeResponseValue;
31263 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
31265 export function ChannelUsage_set_effective_capacity(this_ptr: number, val: number): void {
31266 if(!isWasmInitialized) {
31267 throw new Error("initializeWasm() must be awaited first!");
31269 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
31270 // debug statements here
31272 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
31274 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: number): number {
31275 if(!isWasmInitialized) {
31276 throw new Error("initializeWasm() must be awaited first!");
31278 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
31279 return nativeResponseValue;
31281 // uintptr_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
31283 export function ChannelUsage_clone_ptr(arg: number): number {
31284 if(!isWasmInitialized) {
31285 throw new Error("initializeWasm() must be awaited first!");
31287 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
31288 return nativeResponseValue;
31290 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
31292 export function ChannelUsage_clone(orig: number): number {
31293 if(!isWasmInitialized) {
31294 throw new Error("initializeWasm() must be awaited first!");
31296 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
31297 return nativeResponseValue;
31299 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
31301 export function FixedPenaltyScorer_free(this_obj: number): void {
31302 if(!isWasmInitialized) {
31303 throw new Error("initializeWasm() must be awaited first!");
31305 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
31306 // debug statements here
31308 // uintptr_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
31310 export function FixedPenaltyScorer_clone_ptr(arg: number): number {
31311 if(!isWasmInitialized) {
31312 throw new Error("initializeWasm() must be awaited first!");
31314 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
31315 return nativeResponseValue;
31317 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
31319 export function FixedPenaltyScorer_clone(orig: number): number {
31320 if(!isWasmInitialized) {
31321 throw new Error("initializeWasm() must be awaited first!");
31323 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
31324 return nativeResponseValue;
31326 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
31328 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): number {
31329 if(!isWasmInitialized) {
31330 throw new Error("initializeWasm() must be awaited first!");
31332 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
31333 return nativeResponseValue;
31335 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
31337 export function FixedPenaltyScorer_as_Score(this_arg: number): number {
31338 if(!isWasmInitialized) {
31339 throw new Error("initializeWasm() must be awaited first!");
31341 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
31342 return nativeResponseValue;
31344 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
31346 export function FixedPenaltyScorer_write(obj: number): number {
31347 if(!isWasmInitialized) {
31348 throw new Error("initializeWasm() must be awaited first!");
31350 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
31351 return nativeResponseValue;
31353 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
31355 export function FixedPenaltyScorer_read(ser: number, arg: bigint): number {
31356 if(!isWasmInitialized) {
31357 throw new Error("initializeWasm() must be awaited first!");
31359 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
31360 return nativeResponseValue;
31362 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
31364 export function ProbabilisticScorer_free(this_obj: number): void {
31365 if(!isWasmInitialized) {
31366 throw new Error("initializeWasm() must be awaited first!");
31368 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
31369 // debug statements here
31371 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
31373 export function ProbabilisticScoringParameters_free(this_obj: number): void {
31374 if(!isWasmInitialized) {
31375 throw new Error("initializeWasm() must be awaited first!");
31377 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
31378 // debug statements here
31380 // uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31382 export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: number): bigint {
31383 if(!isWasmInitialized) {
31384 throw new Error("initializeWasm() must be awaited first!");
31386 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
31387 return nativeResponseValue;
31389 // void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31391 export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: number, val: bigint): void {
31392 if(!isWasmInitialized) {
31393 throw new Error("initializeWasm() must be awaited first!");
31395 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
31396 // debug statements here
31398 // uint64_t ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31400 export function ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr: number): bigint {
31401 if(!isWasmInitialized) {
31402 throw new Error("initializeWasm() must be awaited first!");
31404 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(this_ptr);
31405 return nativeResponseValue;
31407 // void ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31409 export function ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr: number, val: bigint): void {
31410 if(!isWasmInitialized) {
31411 throw new Error("initializeWasm() must be awaited first!");
31413 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(this_ptr, val);
31414 // debug statements here
31416 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31418 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: number): bigint {
31419 if(!isWasmInitialized) {
31420 throw new Error("initializeWasm() must be awaited first!");
31422 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
31423 return nativeResponseValue;
31425 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31427 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
31428 if(!isWasmInitialized) {
31429 throw new Error("initializeWasm() must be awaited first!");
31431 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
31432 // debug statements here
31434 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31436 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: number): bigint {
31437 if(!isWasmInitialized) {
31438 throw new Error("initializeWasm() must be awaited first!");
31440 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
31441 return nativeResponseValue;
31443 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31445 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: number, val: bigint): void {
31446 if(!isWasmInitialized) {
31447 throw new Error("initializeWasm() must be awaited first!");
31449 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
31450 // debug statements here
31452 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31454 export function ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr: number): bigint {
31455 if(!isWasmInitialized) {
31456 throw new Error("initializeWasm() must be awaited first!");
31458 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(this_ptr);
31459 return nativeResponseValue;
31461 // void ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31463 export function ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr: number, val: bigint): void {
31464 if(!isWasmInitialized) {
31465 throw new Error("initializeWasm() must be awaited first!");
31467 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(this_ptr, val);
31468 // debug statements here
31470 // uint64_t ProbabilisticScoringParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31472 export function ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: number): bigint {
31473 if(!isWasmInitialized) {
31474 throw new Error("initializeWasm() must be awaited first!");
31476 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr);
31477 return nativeResponseValue;
31479 // void ProbabilisticScoringParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31481 export function ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: number, val: bigint): void {
31482 if(!isWasmInitialized) {
31483 throw new Error("initializeWasm() must be awaited first!");
31485 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr, val);
31486 // debug statements here
31488 // uint64_t ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
31490 export function ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr: number): bigint {
31491 if(!isWasmInitialized) {
31492 throw new Error("initializeWasm() must be awaited first!");
31494 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(this_ptr);
31495 return nativeResponseValue;
31497 // void ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
31499 export function ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr: number, val: bigint): void {
31500 if(!isWasmInitialized) {
31501 throw new Error("initializeWasm() must be awaited first!");
31503 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(this_ptr, val);
31504 // debug statements here
31506 // uintptr_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
31508 export function ProbabilisticScoringParameters_clone_ptr(arg: number): number {
31509 if(!isWasmInitialized) {
31510 throw new Error("initializeWasm() must be awaited first!");
31512 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
31513 return nativeResponseValue;
31515 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
31517 export function ProbabilisticScoringParameters_clone(orig: number): number {
31518 if(!isWasmInitialized) {
31519 throw new Error("initializeWasm() must be awaited first!");
31521 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
31522 return nativeResponseValue;
31524 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
31526 export function ProbabilisticScorer_new(params: number, network_graph: number, logger: number): number {
31527 if(!isWasmInitialized) {
31528 throw new Error("initializeWasm() must be awaited first!");
31530 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
31531 return nativeResponseValue;
31533 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
31535 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: number): void {
31536 if(!isWasmInitialized) {
31537 throw new Error("initializeWasm() must be awaited first!");
31539 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
31540 // debug statements here
31542 // 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);
31544 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: number, scid: bigint, target: number): number {
31545 if(!isWasmInitialized) {
31546 throw new Error("initializeWasm() must be awaited first!");
31548 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
31549 return nativeResponseValue;
31551 // void ProbabilisticScorer_add_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
31553 export function ProbabilisticScorer_add_banned(this_arg: number, node_id: number): void {
31554 if(!isWasmInitialized) {
31555 throw new Error("initializeWasm() must be awaited first!");
31557 const nativeResponseValue = wasm.TS_ProbabilisticScorer_add_banned(this_arg, node_id);
31558 // debug statements here
31560 // void ProbabilisticScorer_remove_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
31562 export function ProbabilisticScorer_remove_banned(this_arg: number, node_id: number): void {
31563 if(!isWasmInitialized) {
31564 throw new Error("initializeWasm() must be awaited first!");
31566 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_banned(this_arg, node_id);
31567 // debug statements here
31569 // void ProbabilisticScorer_set_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id, uint64_t penalty);
31571 export function ProbabilisticScorer_set_manual_penalty(this_arg: number, node_id: number, penalty: bigint): void {
31572 if(!isWasmInitialized) {
31573 throw new Error("initializeWasm() must be awaited first!");
31575 const nativeResponseValue = wasm.TS_ProbabilisticScorer_set_manual_penalty(this_arg, node_id, penalty);
31576 // debug statements here
31578 // void ProbabilisticScorer_remove_manual_penalty(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
31580 export function ProbabilisticScorer_remove_manual_penalty(this_arg: number, node_id: number): void {
31581 if(!isWasmInitialized) {
31582 throw new Error("initializeWasm() must be awaited first!");
31584 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_manual_penalty(this_arg, node_id);
31585 // debug statements here
31587 // void ProbabilisticScorer_clear_manual_penalties(struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
31589 export function ProbabilisticScorer_clear_manual_penalties(this_arg: number): void {
31590 if(!isWasmInitialized) {
31591 throw new Error("initializeWasm() must be awaited first!");
31593 const nativeResponseValue = wasm.TS_ProbabilisticScorer_clear_manual_penalties(this_arg);
31594 // debug statements here
31596 // void ProbabilisticScoringParameters_add_banned_from_list(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
31598 export function ProbabilisticScoringParameters_add_banned_from_list(this_arg: number, node_ids: number): void {
31599 if(!isWasmInitialized) {
31600 throw new Error("initializeWasm() must be awaited first!");
31602 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_add_banned_from_list(this_arg, node_ids);
31603 // debug statements here
31605 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
31607 export function ProbabilisticScoringParameters_default(): number {
31608 if(!isWasmInitialized) {
31609 throw new Error("initializeWasm() must be awaited first!");
31611 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
31612 return nativeResponseValue;
31614 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
31616 export function ProbabilisticScorer_as_Score(this_arg: number): number {
31617 if(!isWasmInitialized) {
31618 throw new Error("initializeWasm() must be awaited first!");
31620 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
31621 return nativeResponseValue;
31623 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
31625 export function ProbabilisticScorer_write(obj: number): number {
31626 if(!isWasmInitialized) {
31627 throw new Error("initializeWasm() must be awaited first!");
31629 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
31630 return nativeResponseValue;
31632 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
31634 export function ProbabilisticScorer_read(ser: number, arg_a: number, arg_b: number, arg_c: number): number {
31635 if(!isWasmInitialized) {
31636 throw new Error("initializeWasm() must be awaited first!");
31638 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
31639 return nativeResponseValue;
31641 // void ParseError_free(struct LDKParseError this_ptr);
31643 export function ParseError_free(this_ptr: number): void {
31644 if(!isWasmInitialized) {
31645 throw new Error("initializeWasm() must be awaited first!");
31647 const nativeResponseValue = wasm.TS_ParseError_free(this_ptr);
31648 // debug statements here
31650 // uintptr_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg);
31652 export function ParseError_clone_ptr(arg: number): number {
31653 if(!isWasmInitialized) {
31654 throw new Error("initializeWasm() must be awaited first!");
31656 const nativeResponseValue = wasm.TS_ParseError_clone_ptr(arg);
31657 return nativeResponseValue;
31659 // struct LDKParseError ParseError_clone(const struct LDKParseError *NONNULL_PTR orig);
31661 export function ParseError_clone(orig: number): number {
31662 if(!isWasmInitialized) {
31663 throw new Error("initializeWasm() must be awaited first!");
31665 const nativeResponseValue = wasm.TS_ParseError_clone(orig);
31666 return nativeResponseValue;
31668 // struct LDKParseError ParseError_bech32_error(struct LDKBech32Error a);
31670 export function ParseError_bech32_error(a: number): number {
31671 if(!isWasmInitialized) {
31672 throw new Error("initializeWasm() must be awaited first!");
31674 const nativeResponseValue = wasm.TS_ParseError_bech32_error(a);
31675 return nativeResponseValue;
31677 // struct LDKParseError ParseError_parse_amount_error(struct LDKError a);
31679 export function ParseError_parse_amount_error(a: number): number {
31680 if(!isWasmInitialized) {
31681 throw new Error("initializeWasm() must be awaited first!");
31683 const nativeResponseValue = wasm.TS_ParseError_parse_amount_error(a);
31684 return nativeResponseValue;
31686 // struct LDKParseError ParseError_malformed_signature(enum LDKSecp256k1Error a);
31688 export function ParseError_malformed_signature(a: Secp256k1Error): number {
31689 if(!isWasmInitialized) {
31690 throw new Error("initializeWasm() must be awaited first!");
31692 const nativeResponseValue = wasm.TS_ParseError_malformed_signature(a);
31693 return nativeResponseValue;
31695 // struct LDKParseError ParseError_bad_prefix(void);
31697 export function ParseError_bad_prefix(): number {
31698 if(!isWasmInitialized) {
31699 throw new Error("initializeWasm() must be awaited first!");
31701 const nativeResponseValue = wasm.TS_ParseError_bad_prefix();
31702 return nativeResponseValue;
31704 // struct LDKParseError ParseError_unknown_currency(void);
31706 export function ParseError_unknown_currency(): number {
31707 if(!isWasmInitialized) {
31708 throw new Error("initializeWasm() must be awaited first!");
31710 const nativeResponseValue = wasm.TS_ParseError_unknown_currency();
31711 return nativeResponseValue;
31713 // struct LDKParseError ParseError_unknown_si_prefix(void);
31715 export function ParseError_unknown_si_prefix(): number {
31716 if(!isWasmInitialized) {
31717 throw new Error("initializeWasm() must be awaited first!");
31719 const nativeResponseValue = wasm.TS_ParseError_unknown_si_prefix();
31720 return nativeResponseValue;
31722 // struct LDKParseError ParseError_malformed_hrp(void);
31724 export function ParseError_malformed_hrp(): number {
31725 if(!isWasmInitialized) {
31726 throw new Error("initializeWasm() must be awaited first!");
31728 const nativeResponseValue = wasm.TS_ParseError_malformed_hrp();
31729 return nativeResponseValue;
31731 // struct LDKParseError ParseError_too_short_data_part(void);
31733 export function ParseError_too_short_data_part(): number {
31734 if(!isWasmInitialized) {
31735 throw new Error("initializeWasm() must be awaited first!");
31737 const nativeResponseValue = wasm.TS_ParseError_too_short_data_part();
31738 return nativeResponseValue;
31740 // struct LDKParseError ParseError_unexpected_end_of_tagged_fields(void);
31742 export function ParseError_unexpected_end_of_tagged_fields(): number {
31743 if(!isWasmInitialized) {
31744 throw new Error("initializeWasm() must be awaited first!");
31746 const nativeResponseValue = wasm.TS_ParseError_unexpected_end_of_tagged_fields();
31747 return nativeResponseValue;
31749 // struct LDKParseError ParseError_description_decode_error(struct LDKError a);
31751 export function ParseError_description_decode_error(a: number): number {
31752 if(!isWasmInitialized) {
31753 throw new Error("initializeWasm() must be awaited first!");
31755 const nativeResponseValue = wasm.TS_ParseError_description_decode_error(a);
31756 return nativeResponseValue;
31758 // struct LDKParseError ParseError_padding_error(void);
31760 export function ParseError_padding_error(): number {
31761 if(!isWasmInitialized) {
31762 throw new Error("initializeWasm() must be awaited first!");
31764 const nativeResponseValue = wasm.TS_ParseError_padding_error();
31765 return nativeResponseValue;
31767 // struct LDKParseError ParseError_integer_overflow_error(void);
31769 export function ParseError_integer_overflow_error(): number {
31770 if(!isWasmInitialized) {
31771 throw new Error("initializeWasm() must be awaited first!");
31773 const nativeResponseValue = wasm.TS_ParseError_integer_overflow_error();
31774 return nativeResponseValue;
31776 // struct LDKParseError ParseError_invalid_seg_wit_program_length(void);
31778 export function ParseError_invalid_seg_wit_program_length(): number {
31779 if(!isWasmInitialized) {
31780 throw new Error("initializeWasm() must be awaited first!");
31782 const nativeResponseValue = wasm.TS_ParseError_invalid_seg_wit_program_length();
31783 return nativeResponseValue;
31785 // struct LDKParseError ParseError_invalid_pub_key_hash_length(void);
31787 export function ParseError_invalid_pub_key_hash_length(): number {
31788 if(!isWasmInitialized) {
31789 throw new Error("initializeWasm() must be awaited first!");
31791 const nativeResponseValue = wasm.TS_ParseError_invalid_pub_key_hash_length();
31792 return nativeResponseValue;
31794 // struct LDKParseError ParseError_invalid_script_hash_length(void);
31796 export function ParseError_invalid_script_hash_length(): number {
31797 if(!isWasmInitialized) {
31798 throw new Error("initializeWasm() must be awaited first!");
31800 const nativeResponseValue = wasm.TS_ParseError_invalid_script_hash_length();
31801 return nativeResponseValue;
31803 // struct LDKParseError ParseError_invalid_recovery_id(void);
31805 export function ParseError_invalid_recovery_id(): number {
31806 if(!isWasmInitialized) {
31807 throw new Error("initializeWasm() must be awaited first!");
31809 const nativeResponseValue = wasm.TS_ParseError_invalid_recovery_id();
31810 return nativeResponseValue;
31812 // struct LDKParseError ParseError_invalid_slice_length(struct LDKStr a);
31814 export function ParseError_invalid_slice_length(a: number): number {
31815 if(!isWasmInitialized) {
31816 throw new Error("initializeWasm() must be awaited first!");
31818 const nativeResponseValue = wasm.TS_ParseError_invalid_slice_length(a);
31819 return nativeResponseValue;
31821 // struct LDKParseError ParseError_skip(void);
31823 export function ParseError_skip(): number {
31824 if(!isWasmInitialized) {
31825 throw new Error("initializeWasm() must be awaited first!");
31827 const nativeResponseValue = wasm.TS_ParseError_skip();
31828 return nativeResponseValue;
31830 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
31832 export function ParseOrSemanticError_free(this_ptr: number): void {
31833 if(!isWasmInitialized) {
31834 throw new Error("initializeWasm() must be awaited first!");
31836 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
31837 // debug statements here
31839 // uintptr_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
31841 export function ParseOrSemanticError_clone_ptr(arg: number): number {
31842 if(!isWasmInitialized) {
31843 throw new Error("initializeWasm() must be awaited first!");
31845 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
31846 return nativeResponseValue;
31848 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
31850 export function ParseOrSemanticError_clone(orig: number): number {
31851 if(!isWasmInitialized) {
31852 throw new Error("initializeWasm() must be awaited first!");
31854 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
31855 return nativeResponseValue;
31857 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKParseError a);
31859 export function ParseOrSemanticError_parse_error(a: number): number {
31860 if(!isWasmInitialized) {
31861 throw new Error("initializeWasm() must be awaited first!");
31863 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
31864 return nativeResponseValue;
31866 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKSemanticError a);
31868 export function ParseOrSemanticError_semantic_error(a: SemanticError): number {
31869 if(!isWasmInitialized) {
31870 throw new Error("initializeWasm() must be awaited first!");
31872 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
31873 return nativeResponseValue;
31875 // void Invoice_free(struct LDKInvoice this_obj);
31877 export function Invoice_free(this_obj: number): void {
31878 if(!isWasmInitialized) {
31879 throw new Error("initializeWasm() must be awaited first!");
31881 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
31882 // debug statements here
31884 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
31886 export function Invoice_eq(a: number, b: number): boolean {
31887 if(!isWasmInitialized) {
31888 throw new Error("initializeWasm() must be awaited first!");
31890 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
31891 return nativeResponseValue;
31893 // uintptr_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
31895 export function Invoice_clone_ptr(arg: number): number {
31896 if(!isWasmInitialized) {
31897 throw new Error("initializeWasm() must be awaited first!");
31899 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
31900 return nativeResponseValue;
31902 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
31904 export function Invoice_clone(orig: number): number {
31905 if(!isWasmInitialized) {
31906 throw new Error("initializeWasm() must be awaited first!");
31908 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
31909 return nativeResponseValue;
31911 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
31913 export function SignedRawInvoice_free(this_obj: number): void {
31914 if(!isWasmInitialized) {
31915 throw new Error("initializeWasm() must be awaited first!");
31917 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
31918 // debug statements here
31920 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
31922 export function SignedRawInvoice_eq(a: number, b: number): boolean {
31923 if(!isWasmInitialized) {
31924 throw new Error("initializeWasm() must be awaited first!");
31926 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
31927 return nativeResponseValue;
31929 // uintptr_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
31931 export function SignedRawInvoice_clone_ptr(arg: number): number {
31932 if(!isWasmInitialized) {
31933 throw new Error("initializeWasm() must be awaited first!");
31935 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
31936 return nativeResponseValue;
31938 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
31940 export function SignedRawInvoice_clone(orig: number): number {
31941 if(!isWasmInitialized) {
31942 throw new Error("initializeWasm() must be awaited first!");
31944 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
31945 return nativeResponseValue;
31947 // void RawInvoice_free(struct LDKRawInvoice this_obj);
31949 export function RawInvoice_free(this_obj: number): void {
31950 if(!isWasmInitialized) {
31951 throw new Error("initializeWasm() must be awaited first!");
31953 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
31954 // debug statements here
31956 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
31958 export function RawInvoice_get_data(this_ptr: number): number {
31959 if(!isWasmInitialized) {
31960 throw new Error("initializeWasm() must be awaited first!");
31962 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
31963 return nativeResponseValue;
31965 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
31967 export function RawInvoice_set_data(this_ptr: number, val: number): void {
31968 if(!isWasmInitialized) {
31969 throw new Error("initializeWasm() must be awaited first!");
31971 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
31972 // debug statements here
31974 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
31976 export function RawInvoice_eq(a: number, b: number): boolean {
31977 if(!isWasmInitialized) {
31978 throw new Error("initializeWasm() must be awaited first!");
31980 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
31981 return nativeResponseValue;
31983 // uintptr_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
31985 export function RawInvoice_clone_ptr(arg: number): number {
31986 if(!isWasmInitialized) {
31987 throw new Error("initializeWasm() must be awaited first!");
31989 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
31990 return nativeResponseValue;
31992 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
31994 export function RawInvoice_clone(orig: number): number {
31995 if(!isWasmInitialized) {
31996 throw new Error("initializeWasm() must be awaited first!");
31998 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
31999 return nativeResponseValue;
32001 // void RawDataPart_free(struct LDKRawDataPart this_obj);
32003 export function RawDataPart_free(this_obj: number): void {
32004 if(!isWasmInitialized) {
32005 throw new Error("initializeWasm() must be awaited first!");
32007 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
32008 // debug statements here
32010 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
32012 export function RawDataPart_get_timestamp(this_ptr: number): number {
32013 if(!isWasmInitialized) {
32014 throw new Error("initializeWasm() must be awaited first!");
32016 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
32017 return nativeResponseValue;
32019 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
32021 export function RawDataPart_set_timestamp(this_ptr: number, val: number): void {
32022 if(!isWasmInitialized) {
32023 throw new Error("initializeWasm() must be awaited first!");
32025 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
32026 // debug statements here
32028 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
32030 export function RawDataPart_eq(a: number, b: number): boolean {
32031 if(!isWasmInitialized) {
32032 throw new Error("initializeWasm() must be awaited first!");
32034 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
32035 return nativeResponseValue;
32037 // uintptr_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
32039 export function RawDataPart_clone_ptr(arg: number): number {
32040 if(!isWasmInitialized) {
32041 throw new Error("initializeWasm() must be awaited first!");
32043 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
32044 return nativeResponseValue;
32046 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
32048 export function RawDataPart_clone(orig: number): number {
32049 if(!isWasmInitialized) {
32050 throw new Error("initializeWasm() must be awaited first!");
32052 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
32053 return nativeResponseValue;
32055 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
32057 export function PositiveTimestamp_free(this_obj: number): void {
32058 if(!isWasmInitialized) {
32059 throw new Error("initializeWasm() must be awaited first!");
32061 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
32062 // debug statements here
32064 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
32066 export function PositiveTimestamp_eq(a: number, b: number): boolean {
32067 if(!isWasmInitialized) {
32068 throw new Error("initializeWasm() must be awaited first!");
32070 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
32071 return nativeResponseValue;
32073 // uintptr_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
32075 export function PositiveTimestamp_clone_ptr(arg: number): number {
32076 if(!isWasmInitialized) {
32077 throw new Error("initializeWasm() must be awaited first!");
32079 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
32080 return nativeResponseValue;
32082 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
32084 export function PositiveTimestamp_clone(orig: number): number {
32085 if(!isWasmInitialized) {
32086 throw new Error("initializeWasm() must be awaited first!");
32088 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
32089 return nativeResponseValue;
32091 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
32093 export function SiPrefix_clone(orig: number): SiPrefix {
32094 if(!isWasmInitialized) {
32095 throw new Error("initializeWasm() must be awaited first!");
32097 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
32098 return nativeResponseValue;
32100 // enum LDKSiPrefix SiPrefix_milli(void);
32102 export function SiPrefix_milli(): SiPrefix {
32103 if(!isWasmInitialized) {
32104 throw new Error("initializeWasm() must be awaited first!");
32106 const nativeResponseValue = wasm.TS_SiPrefix_milli();
32107 return nativeResponseValue;
32109 // enum LDKSiPrefix SiPrefix_micro(void);
32111 export function SiPrefix_micro(): SiPrefix {
32112 if(!isWasmInitialized) {
32113 throw new Error("initializeWasm() must be awaited first!");
32115 const nativeResponseValue = wasm.TS_SiPrefix_micro();
32116 return nativeResponseValue;
32118 // enum LDKSiPrefix SiPrefix_nano(void);
32120 export function SiPrefix_nano(): SiPrefix {
32121 if(!isWasmInitialized) {
32122 throw new Error("initializeWasm() must be awaited first!");
32124 const nativeResponseValue = wasm.TS_SiPrefix_nano();
32125 return nativeResponseValue;
32127 // enum LDKSiPrefix SiPrefix_pico(void);
32129 export function SiPrefix_pico(): SiPrefix {
32130 if(!isWasmInitialized) {
32131 throw new Error("initializeWasm() must be awaited first!");
32133 const nativeResponseValue = wasm.TS_SiPrefix_pico();
32134 return nativeResponseValue;
32136 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
32138 export function SiPrefix_eq(a: number, b: number): boolean {
32139 if(!isWasmInitialized) {
32140 throw new Error("initializeWasm() must be awaited first!");
32142 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
32143 return nativeResponseValue;
32145 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
32147 export function SiPrefix_multiplier(this_arg: number): bigint {
32148 if(!isWasmInitialized) {
32149 throw new Error("initializeWasm() must be awaited first!");
32151 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
32152 return nativeResponseValue;
32154 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
32156 export function Currency_clone(orig: number): Currency {
32157 if(!isWasmInitialized) {
32158 throw new Error("initializeWasm() must be awaited first!");
32160 const nativeResponseValue = wasm.TS_Currency_clone(orig);
32161 return nativeResponseValue;
32163 // enum LDKCurrency Currency_bitcoin(void);
32165 export function Currency_bitcoin(): Currency {
32166 if(!isWasmInitialized) {
32167 throw new Error("initializeWasm() must be awaited first!");
32169 const nativeResponseValue = wasm.TS_Currency_bitcoin();
32170 return nativeResponseValue;
32172 // enum LDKCurrency Currency_bitcoin_testnet(void);
32174 export function Currency_bitcoin_testnet(): Currency {
32175 if(!isWasmInitialized) {
32176 throw new Error("initializeWasm() must be awaited first!");
32178 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
32179 return nativeResponseValue;
32181 // enum LDKCurrency Currency_regtest(void);
32183 export function Currency_regtest(): Currency {
32184 if(!isWasmInitialized) {
32185 throw new Error("initializeWasm() must be awaited first!");
32187 const nativeResponseValue = wasm.TS_Currency_regtest();
32188 return nativeResponseValue;
32190 // enum LDKCurrency Currency_simnet(void);
32192 export function Currency_simnet(): Currency {
32193 if(!isWasmInitialized) {
32194 throw new Error("initializeWasm() must be awaited first!");
32196 const nativeResponseValue = wasm.TS_Currency_simnet();
32197 return nativeResponseValue;
32199 // enum LDKCurrency Currency_signet(void);
32201 export function Currency_signet(): Currency {
32202 if(!isWasmInitialized) {
32203 throw new Error("initializeWasm() must be awaited first!");
32205 const nativeResponseValue = wasm.TS_Currency_signet();
32206 return nativeResponseValue;
32208 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
32210 export function Currency_hash(o: number): bigint {
32211 if(!isWasmInitialized) {
32212 throw new Error("initializeWasm() must be awaited first!");
32214 const nativeResponseValue = wasm.TS_Currency_hash(o);
32215 return nativeResponseValue;
32217 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
32219 export function Currency_eq(a: number, b: number): boolean {
32220 if(!isWasmInitialized) {
32221 throw new Error("initializeWasm() must be awaited first!");
32223 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
32224 return nativeResponseValue;
32226 // void Sha256_free(struct LDKSha256 this_obj);
32228 export function Sha256_free(this_obj: number): void {
32229 if(!isWasmInitialized) {
32230 throw new Error("initializeWasm() must be awaited first!");
32232 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
32233 // debug statements here
32235 // uintptr_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
32237 export function Sha256_clone_ptr(arg: number): number {
32238 if(!isWasmInitialized) {
32239 throw new Error("initializeWasm() must be awaited first!");
32241 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
32242 return nativeResponseValue;
32244 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
32246 export function Sha256_clone(orig: number): number {
32247 if(!isWasmInitialized) {
32248 throw new Error("initializeWasm() must be awaited first!");
32250 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
32251 return nativeResponseValue;
32253 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
32255 export function Sha256_hash(o: number): bigint {
32256 if(!isWasmInitialized) {
32257 throw new Error("initializeWasm() must be awaited first!");
32259 const nativeResponseValue = wasm.TS_Sha256_hash(o);
32260 return nativeResponseValue;
32262 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
32264 export function Sha256_eq(a: number, b: number): boolean {
32265 if(!isWasmInitialized) {
32266 throw new Error("initializeWasm() must be awaited first!");
32268 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
32269 return nativeResponseValue;
32271 // void Description_free(struct LDKDescription this_obj);
32273 export function Description_free(this_obj: number): void {
32274 if(!isWasmInitialized) {
32275 throw new Error("initializeWasm() must be awaited first!");
32277 const nativeResponseValue = wasm.TS_Description_free(this_obj);
32278 // debug statements here
32280 // uintptr_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
32282 export function Description_clone_ptr(arg: number): number {
32283 if(!isWasmInitialized) {
32284 throw new Error("initializeWasm() must be awaited first!");
32286 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
32287 return nativeResponseValue;
32289 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
32291 export function Description_clone(orig: number): number {
32292 if(!isWasmInitialized) {
32293 throw new Error("initializeWasm() must be awaited first!");
32295 const nativeResponseValue = wasm.TS_Description_clone(orig);
32296 return nativeResponseValue;
32298 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
32300 export function Description_hash(o: number): bigint {
32301 if(!isWasmInitialized) {
32302 throw new Error("initializeWasm() must be awaited first!");
32304 const nativeResponseValue = wasm.TS_Description_hash(o);
32305 return nativeResponseValue;
32307 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
32309 export function Description_eq(a: number, b: number): boolean {
32310 if(!isWasmInitialized) {
32311 throw new Error("initializeWasm() must be awaited first!");
32313 const nativeResponseValue = wasm.TS_Description_eq(a, b);
32314 return nativeResponseValue;
32316 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
32318 export function PayeePubKey_free(this_obj: number): void {
32319 if(!isWasmInitialized) {
32320 throw new Error("initializeWasm() must be awaited first!");
32322 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
32323 // debug statements here
32325 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
32327 export function PayeePubKey_get_a(this_ptr: number): number {
32328 if(!isWasmInitialized) {
32329 throw new Error("initializeWasm() must be awaited first!");
32331 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
32332 return nativeResponseValue;
32334 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
32336 export function PayeePubKey_set_a(this_ptr: number, val: number): void {
32337 if(!isWasmInitialized) {
32338 throw new Error("initializeWasm() must be awaited first!");
32340 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
32341 // debug statements here
32343 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
32345 export function PayeePubKey_new(a_arg: number): number {
32346 if(!isWasmInitialized) {
32347 throw new Error("initializeWasm() must be awaited first!");
32349 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
32350 return nativeResponseValue;
32352 // uintptr_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
32354 export function PayeePubKey_clone_ptr(arg: number): number {
32355 if(!isWasmInitialized) {
32356 throw new Error("initializeWasm() must be awaited first!");
32358 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
32359 return nativeResponseValue;
32361 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
32363 export function PayeePubKey_clone(orig: number): number {
32364 if(!isWasmInitialized) {
32365 throw new Error("initializeWasm() must be awaited first!");
32367 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
32368 return nativeResponseValue;
32370 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
32372 export function PayeePubKey_hash(o: number): bigint {
32373 if(!isWasmInitialized) {
32374 throw new Error("initializeWasm() must be awaited first!");
32376 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
32377 return nativeResponseValue;
32379 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
32381 export function PayeePubKey_eq(a: number, b: number): boolean {
32382 if(!isWasmInitialized) {
32383 throw new Error("initializeWasm() must be awaited first!");
32385 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
32386 return nativeResponseValue;
32388 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
32390 export function ExpiryTime_free(this_obj: number): void {
32391 if(!isWasmInitialized) {
32392 throw new Error("initializeWasm() must be awaited first!");
32394 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
32395 // debug statements here
32397 // uintptr_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
32399 export function ExpiryTime_clone_ptr(arg: number): number {
32400 if(!isWasmInitialized) {
32401 throw new Error("initializeWasm() must be awaited first!");
32403 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
32404 return nativeResponseValue;
32406 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
32408 export function ExpiryTime_clone(orig: number): number {
32409 if(!isWasmInitialized) {
32410 throw new Error("initializeWasm() must be awaited first!");
32412 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
32413 return nativeResponseValue;
32415 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
32417 export function ExpiryTime_hash(o: number): bigint {
32418 if(!isWasmInitialized) {
32419 throw new Error("initializeWasm() must be awaited first!");
32421 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
32422 return nativeResponseValue;
32424 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
32426 export function ExpiryTime_eq(a: number, b: number): boolean {
32427 if(!isWasmInitialized) {
32428 throw new Error("initializeWasm() must be awaited first!");
32430 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
32431 return nativeResponseValue;
32433 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
32435 export function MinFinalCltvExpiry_free(this_obj: number): void {
32436 if(!isWasmInitialized) {
32437 throw new Error("initializeWasm() must be awaited first!");
32439 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
32440 // debug statements here
32442 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
32444 export function MinFinalCltvExpiry_get_a(this_ptr: number): bigint {
32445 if(!isWasmInitialized) {
32446 throw new Error("initializeWasm() must be awaited first!");
32448 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
32449 return nativeResponseValue;
32451 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
32453 export function MinFinalCltvExpiry_set_a(this_ptr: number, val: bigint): void {
32454 if(!isWasmInitialized) {
32455 throw new Error("initializeWasm() must be awaited first!");
32457 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
32458 // debug statements here
32460 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
32462 export function MinFinalCltvExpiry_new(a_arg: bigint): number {
32463 if(!isWasmInitialized) {
32464 throw new Error("initializeWasm() must be awaited first!");
32466 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
32467 return nativeResponseValue;
32469 // uintptr_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
32471 export function MinFinalCltvExpiry_clone_ptr(arg: number): number {
32472 if(!isWasmInitialized) {
32473 throw new Error("initializeWasm() must be awaited first!");
32475 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
32476 return nativeResponseValue;
32478 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
32480 export function MinFinalCltvExpiry_clone(orig: number): number {
32481 if(!isWasmInitialized) {
32482 throw new Error("initializeWasm() must be awaited first!");
32484 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
32485 return nativeResponseValue;
32487 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
32489 export function MinFinalCltvExpiry_hash(o: number): bigint {
32490 if(!isWasmInitialized) {
32491 throw new Error("initializeWasm() must be awaited first!");
32493 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
32494 return nativeResponseValue;
32496 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
32498 export function MinFinalCltvExpiry_eq(a: number, b: number): boolean {
32499 if(!isWasmInitialized) {
32500 throw new Error("initializeWasm() must be awaited first!");
32502 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
32503 return nativeResponseValue;
32505 // void Fallback_free(struct LDKFallback this_ptr);
32507 export function Fallback_free(this_ptr: number): void {
32508 if(!isWasmInitialized) {
32509 throw new Error("initializeWasm() must be awaited first!");
32511 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
32512 // debug statements here
32514 // uintptr_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
32516 export function Fallback_clone_ptr(arg: number): number {
32517 if(!isWasmInitialized) {
32518 throw new Error("initializeWasm() must be awaited first!");
32520 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
32521 return nativeResponseValue;
32523 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
32525 export function Fallback_clone(orig: number): number {
32526 if(!isWasmInitialized) {
32527 throw new Error("initializeWasm() must be awaited first!");
32529 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
32530 return nativeResponseValue;
32532 // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
32534 export function Fallback_seg_wit_program(version: number, program: number): number {
32535 if(!isWasmInitialized) {
32536 throw new Error("initializeWasm() must be awaited first!");
32538 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
32539 return nativeResponseValue;
32541 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
32543 export function Fallback_pub_key_hash(a: number): number {
32544 if(!isWasmInitialized) {
32545 throw new Error("initializeWasm() must be awaited first!");
32547 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
32548 return nativeResponseValue;
32550 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
32552 export function Fallback_script_hash(a: number): number {
32553 if(!isWasmInitialized) {
32554 throw new Error("initializeWasm() must be awaited first!");
32556 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
32557 return nativeResponseValue;
32559 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
32561 export function Fallback_hash(o: number): bigint {
32562 if(!isWasmInitialized) {
32563 throw new Error("initializeWasm() must be awaited first!");
32565 const nativeResponseValue = wasm.TS_Fallback_hash(o);
32566 return nativeResponseValue;
32568 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
32570 export function Fallback_eq(a: number, b: number): boolean {
32571 if(!isWasmInitialized) {
32572 throw new Error("initializeWasm() must be awaited first!");
32574 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
32575 return nativeResponseValue;
32577 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
32579 export function InvoiceSignature_free(this_obj: number): void {
32580 if(!isWasmInitialized) {
32581 throw new Error("initializeWasm() must be awaited first!");
32583 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
32584 // debug statements here
32586 // uintptr_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
32588 export function InvoiceSignature_clone_ptr(arg: number): number {
32589 if(!isWasmInitialized) {
32590 throw new Error("initializeWasm() must be awaited first!");
32592 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
32593 return nativeResponseValue;
32595 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
32597 export function InvoiceSignature_clone(orig: number): number {
32598 if(!isWasmInitialized) {
32599 throw new Error("initializeWasm() must be awaited first!");
32601 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
32602 return nativeResponseValue;
32604 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
32606 export function InvoiceSignature_eq(a: number, b: number): boolean {
32607 if(!isWasmInitialized) {
32608 throw new Error("initializeWasm() must be awaited first!");
32610 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
32611 return nativeResponseValue;
32613 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
32615 export function PrivateRoute_free(this_obj: number): void {
32616 if(!isWasmInitialized) {
32617 throw new Error("initializeWasm() must be awaited first!");
32619 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
32620 // debug statements here
32622 // uintptr_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
32624 export function PrivateRoute_clone_ptr(arg: number): number {
32625 if(!isWasmInitialized) {
32626 throw new Error("initializeWasm() must be awaited first!");
32628 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
32629 return nativeResponseValue;
32631 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
32633 export function PrivateRoute_clone(orig: number): number {
32634 if(!isWasmInitialized) {
32635 throw new Error("initializeWasm() must be awaited first!");
32637 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
32638 return nativeResponseValue;
32640 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
32642 export function PrivateRoute_hash(o: number): bigint {
32643 if(!isWasmInitialized) {
32644 throw new Error("initializeWasm() must be awaited first!");
32646 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
32647 return nativeResponseValue;
32649 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
32651 export function PrivateRoute_eq(a: number, b: number): boolean {
32652 if(!isWasmInitialized) {
32653 throw new Error("initializeWasm() must be awaited first!");
32655 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
32656 return nativeResponseValue;
32658 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
32660 export function SignedRawInvoice_into_parts(this_arg: number): number {
32661 if(!isWasmInitialized) {
32662 throw new Error("initializeWasm() must be awaited first!");
32664 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
32665 return nativeResponseValue;
32667 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32669 export function SignedRawInvoice_raw_invoice(this_arg: number): number {
32670 if(!isWasmInitialized) {
32671 throw new Error("initializeWasm() must be awaited first!");
32673 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
32674 return nativeResponseValue;
32676 // MUST_USE_RES const uint8_t (*SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
32678 export function SignedRawInvoice_hash(this_arg: number): number {
32679 if(!isWasmInitialized) {
32680 throw new Error("initializeWasm() must be awaited first!");
32682 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(this_arg);
32683 return nativeResponseValue;
32685 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32687 export function SignedRawInvoice_signature(this_arg: number): number {
32688 if(!isWasmInitialized) {
32689 throw new Error("initializeWasm() must be awaited first!");
32691 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
32692 return nativeResponseValue;
32694 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32696 export function SignedRawInvoice_recover_payee_pub_key(this_arg: number): number {
32697 if(!isWasmInitialized) {
32698 throw new Error("initializeWasm() must be awaited first!");
32700 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
32701 return nativeResponseValue;
32703 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32705 export function SignedRawInvoice_check_signature(this_arg: number): boolean {
32706 if(!isWasmInitialized) {
32707 throw new Error("initializeWasm() must be awaited first!");
32709 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
32710 return nativeResponseValue;
32712 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32714 export function RawInvoice_hash(this_arg: number): number {
32715 if(!isWasmInitialized) {
32716 throw new Error("initializeWasm() must be awaited first!");
32718 const nativeResponseValue = wasm.TS_RawInvoice_hash(this_arg);
32719 return nativeResponseValue;
32721 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32723 export function RawInvoice_payment_hash(this_arg: number): number {
32724 if(!isWasmInitialized) {
32725 throw new Error("initializeWasm() must be awaited first!");
32727 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
32728 return nativeResponseValue;
32730 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32732 export function RawInvoice_description(this_arg: number): number {
32733 if(!isWasmInitialized) {
32734 throw new Error("initializeWasm() must be awaited first!");
32736 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
32737 return nativeResponseValue;
32739 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32741 export function RawInvoice_payee_pub_key(this_arg: number): number {
32742 if(!isWasmInitialized) {
32743 throw new Error("initializeWasm() must be awaited first!");
32745 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
32746 return nativeResponseValue;
32748 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32750 export function RawInvoice_description_hash(this_arg: number): number {
32751 if(!isWasmInitialized) {
32752 throw new Error("initializeWasm() must be awaited first!");
32754 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
32755 return nativeResponseValue;
32757 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32759 export function RawInvoice_expiry_time(this_arg: number): number {
32760 if(!isWasmInitialized) {
32761 throw new Error("initializeWasm() must be awaited first!");
32763 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
32764 return nativeResponseValue;
32766 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32768 export function RawInvoice_min_final_cltv_expiry(this_arg: number): number {
32769 if(!isWasmInitialized) {
32770 throw new Error("initializeWasm() must be awaited first!");
32772 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
32773 return nativeResponseValue;
32775 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32777 export function RawInvoice_payment_secret(this_arg: number): number {
32778 if(!isWasmInitialized) {
32779 throw new Error("initializeWasm() must be awaited first!");
32781 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
32782 return nativeResponseValue;
32784 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32786 export function RawInvoice_features(this_arg: number): number {
32787 if(!isWasmInitialized) {
32788 throw new Error("initializeWasm() must be awaited first!");
32790 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
32791 return nativeResponseValue;
32793 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32795 export function RawInvoice_private_routes(this_arg: number): number {
32796 if(!isWasmInitialized) {
32797 throw new Error("initializeWasm() must be awaited first!");
32799 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
32800 return nativeResponseValue;
32802 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32804 export function RawInvoice_amount_pico_btc(this_arg: number): number {
32805 if(!isWasmInitialized) {
32806 throw new Error("initializeWasm() must be awaited first!");
32808 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
32809 return nativeResponseValue;
32811 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32813 export function RawInvoice_currency(this_arg: number): Currency {
32814 if(!isWasmInitialized) {
32815 throw new Error("initializeWasm() must be awaited first!");
32817 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
32818 return nativeResponseValue;
32820 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
32822 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): number {
32823 if(!isWasmInitialized) {
32824 throw new Error("initializeWasm() must be awaited first!");
32826 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
32827 return nativeResponseValue;
32829 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
32831 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): number {
32832 if(!isWasmInitialized) {
32833 throw new Error("initializeWasm() must be awaited first!");
32835 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
32836 return nativeResponseValue;
32838 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
32840 export function PositiveTimestamp_as_unix_timestamp(this_arg: number): bigint {
32841 if(!isWasmInitialized) {
32842 throw new Error("initializeWasm() must be awaited first!");
32844 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
32845 return nativeResponseValue;
32847 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
32849 export function PositiveTimestamp_as_duration_since_epoch(this_arg: number): bigint {
32850 if(!isWasmInitialized) {
32851 throw new Error("initializeWasm() must be awaited first!");
32853 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
32854 return nativeResponseValue;
32856 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
32858 export function Invoice_into_signed_raw(this_arg: number): number {
32859 if(!isWasmInitialized) {
32860 throw new Error("initializeWasm() must be awaited first!");
32862 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
32863 return nativeResponseValue;
32865 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
32867 export function Invoice_check_signature(this_arg: number): number {
32868 if(!isWasmInitialized) {
32869 throw new Error("initializeWasm() must be awaited first!");
32871 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
32872 return nativeResponseValue;
32874 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
32876 export function Invoice_from_signed(signed_invoice: number): number {
32877 if(!isWasmInitialized) {
32878 throw new Error("initializeWasm() must be awaited first!");
32880 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
32881 return nativeResponseValue;
32883 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
32885 export function Invoice_duration_since_epoch(this_arg: number): bigint {
32886 if(!isWasmInitialized) {
32887 throw new Error("initializeWasm() must be awaited first!");
32889 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
32890 return nativeResponseValue;
32892 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
32894 export function Invoice_payment_hash(this_arg: number): number {
32895 if(!isWasmInitialized) {
32896 throw new Error("initializeWasm() must be awaited first!");
32898 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
32899 return nativeResponseValue;
32901 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
32903 export function Invoice_payee_pub_key(this_arg: number): number {
32904 if(!isWasmInitialized) {
32905 throw new Error("initializeWasm() must be awaited first!");
32907 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
32908 return nativeResponseValue;
32910 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
32912 export function Invoice_payment_secret(this_arg: number): number {
32913 if(!isWasmInitialized) {
32914 throw new Error("initializeWasm() must be awaited first!");
32916 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
32917 return nativeResponseValue;
32919 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
32921 export function Invoice_features(this_arg: number): number {
32922 if(!isWasmInitialized) {
32923 throw new Error("initializeWasm() must be awaited first!");
32925 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
32926 return nativeResponseValue;
32928 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
32930 export function Invoice_recover_payee_pub_key(this_arg: number): number {
32931 if(!isWasmInitialized) {
32932 throw new Error("initializeWasm() must be awaited first!");
32934 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
32935 return nativeResponseValue;
32937 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
32939 export function Invoice_expiry_time(this_arg: number): bigint {
32940 if(!isWasmInitialized) {
32941 throw new Error("initializeWasm() must be awaited first!");
32943 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
32944 return nativeResponseValue;
32946 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
32948 export function Invoice_would_expire(this_arg: number, at_time: bigint): boolean {
32949 if(!isWasmInitialized) {
32950 throw new Error("initializeWasm() must be awaited first!");
32952 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
32953 return nativeResponseValue;
32955 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
32957 export function Invoice_min_final_cltv_expiry(this_arg: number): bigint {
32958 if(!isWasmInitialized) {
32959 throw new Error("initializeWasm() must be awaited first!");
32961 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
32962 return nativeResponseValue;
32964 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
32966 export function Invoice_private_routes(this_arg: number): number {
32967 if(!isWasmInitialized) {
32968 throw new Error("initializeWasm() must be awaited first!");
32970 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
32971 return nativeResponseValue;
32973 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
32975 export function Invoice_route_hints(this_arg: number): number {
32976 if(!isWasmInitialized) {
32977 throw new Error("initializeWasm() must be awaited first!");
32979 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
32980 return nativeResponseValue;
32982 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
32984 export function Invoice_currency(this_arg: number): Currency {
32985 if(!isWasmInitialized) {
32986 throw new Error("initializeWasm() must be awaited first!");
32988 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
32989 return nativeResponseValue;
32991 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
32993 export function Invoice_amount_milli_satoshis(this_arg: number): number {
32994 if(!isWasmInitialized) {
32995 throw new Error("initializeWasm() must be awaited first!");
32997 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
32998 return nativeResponseValue;
33000 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
33002 export function Description_new(description: number): number {
33003 if(!isWasmInitialized) {
33004 throw new Error("initializeWasm() must be awaited first!");
33006 const nativeResponseValue = wasm.TS_Description_new(description);
33007 return nativeResponseValue;
33009 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
33011 export function Description_into_inner(this_arg: number): number {
33012 if(!isWasmInitialized) {
33013 throw new Error("initializeWasm() must be awaited first!");
33015 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
33016 return nativeResponseValue;
33018 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
33020 export function ExpiryTime_from_seconds(seconds: bigint): number {
33021 if(!isWasmInitialized) {
33022 throw new Error("initializeWasm() must be awaited first!");
33024 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
33025 return nativeResponseValue;
33027 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
33029 export function ExpiryTime_from_duration(duration: bigint): number {
33030 if(!isWasmInitialized) {
33031 throw new Error("initializeWasm() must be awaited first!");
33033 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
33034 return nativeResponseValue;
33036 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
33038 export function ExpiryTime_as_seconds(this_arg: number): bigint {
33039 if(!isWasmInitialized) {
33040 throw new Error("initializeWasm() must be awaited first!");
33042 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
33043 return nativeResponseValue;
33045 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
33047 export function ExpiryTime_as_duration(this_arg: number): bigint {
33048 if(!isWasmInitialized) {
33049 throw new Error("initializeWasm() must be awaited first!");
33051 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
33052 return nativeResponseValue;
33054 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
33056 export function PrivateRoute_new(hops: number): number {
33057 if(!isWasmInitialized) {
33058 throw new Error("initializeWasm() must be awaited first!");
33060 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
33061 return nativeResponseValue;
33063 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
33065 export function PrivateRoute_into_inner(this_arg: number): number {
33066 if(!isWasmInitialized) {
33067 throw new Error("initializeWasm() must be awaited first!");
33069 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
33070 return nativeResponseValue;
33072 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
33074 export function CreationError_clone(orig: number): CreationError {
33075 if(!isWasmInitialized) {
33076 throw new Error("initializeWasm() must be awaited first!");
33078 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
33079 return nativeResponseValue;
33081 // enum LDKCreationError CreationError_description_too_long(void);
33083 export function CreationError_description_too_long(): CreationError {
33084 if(!isWasmInitialized) {
33085 throw new Error("initializeWasm() must be awaited first!");
33087 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
33088 return nativeResponseValue;
33090 // enum LDKCreationError CreationError_route_too_long(void);
33092 export function CreationError_route_too_long(): CreationError {
33093 if(!isWasmInitialized) {
33094 throw new Error("initializeWasm() must be awaited first!");
33096 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
33097 return nativeResponseValue;
33099 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
33101 export function CreationError_timestamp_out_of_bounds(): CreationError {
33102 if(!isWasmInitialized) {
33103 throw new Error("initializeWasm() must be awaited first!");
33105 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
33106 return nativeResponseValue;
33108 // enum LDKCreationError CreationError_invalid_amount(void);
33110 export function CreationError_invalid_amount(): CreationError {
33111 if(!isWasmInitialized) {
33112 throw new Error("initializeWasm() must be awaited first!");
33114 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
33115 return nativeResponseValue;
33117 // enum LDKCreationError CreationError_missing_route_hints(void);
33119 export function CreationError_missing_route_hints(): CreationError {
33120 if(!isWasmInitialized) {
33121 throw new Error("initializeWasm() must be awaited first!");
33123 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
33124 return nativeResponseValue;
33126 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
33128 export function CreationError_eq(a: number, b: number): boolean {
33129 if(!isWasmInitialized) {
33130 throw new Error("initializeWasm() must be awaited first!");
33132 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
33133 return nativeResponseValue;
33135 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
33137 export function CreationError_to_str(o: number): number {
33138 if(!isWasmInitialized) {
33139 throw new Error("initializeWasm() must be awaited first!");
33141 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
33142 return nativeResponseValue;
33144 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
33146 export function SemanticError_clone(orig: number): SemanticError {
33147 if(!isWasmInitialized) {
33148 throw new Error("initializeWasm() must be awaited first!");
33150 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
33151 return nativeResponseValue;
33153 // enum LDKSemanticError SemanticError_no_payment_hash(void);
33155 export function SemanticError_no_payment_hash(): SemanticError {
33156 if(!isWasmInitialized) {
33157 throw new Error("initializeWasm() must be awaited first!");
33159 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
33160 return nativeResponseValue;
33162 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
33164 export function SemanticError_multiple_payment_hashes(): SemanticError {
33165 if(!isWasmInitialized) {
33166 throw new Error("initializeWasm() must be awaited first!");
33168 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
33169 return nativeResponseValue;
33171 // enum LDKSemanticError SemanticError_no_description(void);
33173 export function SemanticError_no_description(): SemanticError {
33174 if(!isWasmInitialized) {
33175 throw new Error("initializeWasm() must be awaited first!");
33177 const nativeResponseValue = wasm.TS_SemanticError_no_description();
33178 return nativeResponseValue;
33180 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
33182 export function SemanticError_multiple_descriptions(): SemanticError {
33183 if(!isWasmInitialized) {
33184 throw new Error("initializeWasm() must be awaited first!");
33186 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
33187 return nativeResponseValue;
33189 // enum LDKSemanticError SemanticError_no_payment_secret(void);
33191 export function SemanticError_no_payment_secret(): SemanticError {
33192 if(!isWasmInitialized) {
33193 throw new Error("initializeWasm() must be awaited first!");
33195 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
33196 return nativeResponseValue;
33198 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
33200 export function SemanticError_multiple_payment_secrets(): SemanticError {
33201 if(!isWasmInitialized) {
33202 throw new Error("initializeWasm() must be awaited first!");
33204 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
33205 return nativeResponseValue;
33207 // enum LDKSemanticError SemanticError_invalid_features(void);
33209 export function SemanticError_invalid_features(): SemanticError {
33210 if(!isWasmInitialized) {
33211 throw new Error("initializeWasm() must be awaited first!");
33213 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
33214 return nativeResponseValue;
33216 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
33218 export function SemanticError_invalid_recovery_id(): SemanticError {
33219 if(!isWasmInitialized) {
33220 throw new Error("initializeWasm() must be awaited first!");
33222 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
33223 return nativeResponseValue;
33225 // enum LDKSemanticError SemanticError_invalid_signature(void);
33227 export function SemanticError_invalid_signature(): SemanticError {
33228 if(!isWasmInitialized) {
33229 throw new Error("initializeWasm() must be awaited first!");
33231 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
33232 return nativeResponseValue;
33234 // enum LDKSemanticError SemanticError_imprecise_amount(void);
33236 export function SemanticError_imprecise_amount(): SemanticError {
33237 if(!isWasmInitialized) {
33238 throw new Error("initializeWasm() must be awaited first!");
33240 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
33241 return nativeResponseValue;
33243 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
33245 export function SemanticError_eq(a: number, b: number): boolean {
33246 if(!isWasmInitialized) {
33247 throw new Error("initializeWasm() must be awaited first!");
33249 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
33250 return nativeResponseValue;
33252 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
33254 export function SemanticError_to_str(o: number): number {
33255 if(!isWasmInitialized) {
33256 throw new Error("initializeWasm() must be awaited first!");
33258 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
33259 return nativeResponseValue;
33261 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
33263 export function SignOrCreationError_free(this_ptr: number): void {
33264 if(!isWasmInitialized) {
33265 throw new Error("initializeWasm() must be awaited first!");
33267 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
33268 // debug statements here
33270 // uintptr_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
33272 export function SignOrCreationError_clone_ptr(arg: number): number {
33273 if(!isWasmInitialized) {
33274 throw new Error("initializeWasm() must be awaited first!");
33276 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
33277 return nativeResponseValue;
33279 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
33281 export function SignOrCreationError_clone(orig: number): number {
33282 if(!isWasmInitialized) {
33283 throw new Error("initializeWasm() must be awaited first!");
33285 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
33286 return nativeResponseValue;
33288 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
33290 export function SignOrCreationError_sign_error(): number {
33291 if(!isWasmInitialized) {
33292 throw new Error("initializeWasm() must be awaited first!");
33294 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
33295 return nativeResponseValue;
33297 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
33299 export function SignOrCreationError_creation_error(a: CreationError): number {
33300 if(!isWasmInitialized) {
33301 throw new Error("initializeWasm() must be awaited first!");
33303 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
33304 return nativeResponseValue;
33306 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
33308 export function SignOrCreationError_eq(a: number, b: number): boolean {
33309 if(!isWasmInitialized) {
33310 throw new Error("initializeWasm() must be awaited first!");
33312 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
33313 return nativeResponseValue;
33315 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
33317 export function SignOrCreationError_to_str(o: number): number {
33318 if(!isWasmInitialized) {
33319 throw new Error("initializeWasm() must be awaited first!");
33321 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
33322 return nativeResponseValue;
33324 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
33326 export function InvoicePayer_free(this_obj: number): void {
33327 if(!isWasmInitialized) {
33328 throw new Error("initializeWasm() must be awaited first!");
33330 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
33331 // debug statements here
33333 // void Payer_free(struct LDKPayer this_ptr);
33335 export function Payer_free(this_ptr: number): void {
33336 if(!isWasmInitialized) {
33337 throw new Error("initializeWasm() must be awaited first!");
33339 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
33340 // debug statements here
33342 // void Router_free(struct LDKRouter this_ptr);
33344 export function Router_free(this_ptr: number): void {
33345 if(!isWasmInitialized) {
33346 throw new Error("initializeWasm() must be awaited first!");
33348 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
33349 // debug statements here
33351 // void Retry_free(struct LDKRetry this_ptr);
33353 export function Retry_free(this_ptr: number): void {
33354 if(!isWasmInitialized) {
33355 throw new Error("initializeWasm() must be awaited first!");
33357 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
33358 // debug statements here
33360 // uintptr_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
33362 export function Retry_clone_ptr(arg: number): number {
33363 if(!isWasmInitialized) {
33364 throw new Error("initializeWasm() must be awaited first!");
33366 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
33367 return nativeResponseValue;
33369 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
33371 export function Retry_clone(orig: number): number {
33372 if(!isWasmInitialized) {
33373 throw new Error("initializeWasm() must be awaited first!");
33375 const nativeResponseValue = wasm.TS_Retry_clone(orig);
33376 return nativeResponseValue;
33378 // struct LDKRetry Retry_attempts(uintptr_t a);
33380 export function Retry_attempts(a: number): number {
33381 if(!isWasmInitialized) {
33382 throw new Error("initializeWasm() must be awaited first!");
33384 const nativeResponseValue = wasm.TS_Retry_attempts(a);
33385 return nativeResponseValue;
33387 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
33389 export function Retry_eq(a: number, b: number): boolean {
33390 if(!isWasmInitialized) {
33391 throw new Error("initializeWasm() must be awaited first!");
33393 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
33394 return nativeResponseValue;
33396 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
33398 export function Retry_hash(o: number): bigint {
33399 if(!isWasmInitialized) {
33400 throw new Error("initializeWasm() must be awaited first!");
33402 const nativeResponseValue = wasm.TS_Retry_hash(o);
33403 return nativeResponseValue;
33405 // void PaymentError_free(struct LDKPaymentError this_ptr);
33407 export function PaymentError_free(this_ptr: number): void {
33408 if(!isWasmInitialized) {
33409 throw new Error("initializeWasm() must be awaited first!");
33411 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
33412 // debug statements here
33414 // uintptr_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
33416 export function PaymentError_clone_ptr(arg: number): number {
33417 if(!isWasmInitialized) {
33418 throw new Error("initializeWasm() must be awaited first!");
33420 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
33421 return nativeResponseValue;
33423 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
33425 export function PaymentError_clone(orig: number): number {
33426 if(!isWasmInitialized) {
33427 throw new Error("initializeWasm() must be awaited first!");
33429 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
33430 return nativeResponseValue;
33432 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
33434 export function PaymentError_invoice(a: number): number {
33435 if(!isWasmInitialized) {
33436 throw new Error("initializeWasm() must be awaited first!");
33438 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
33439 return nativeResponseValue;
33441 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
33443 export function PaymentError_routing(a: number): number {
33444 if(!isWasmInitialized) {
33445 throw new Error("initializeWasm() must be awaited first!");
33447 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
33448 return nativeResponseValue;
33450 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
33452 export function PaymentError_sending(a: number): number {
33453 if(!isWasmInitialized) {
33454 throw new Error("initializeWasm() must be awaited first!");
33456 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
33457 return nativeResponseValue;
33459 // 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);
33461 export function InvoicePayer_new(payer: number, router: number, scorer: number, logger: number, event_handler: number, retry: number): number {
33462 if(!isWasmInitialized) {
33463 throw new Error("initializeWasm() must be awaited first!");
33465 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, scorer, logger, event_handler, retry);
33466 return nativeResponseValue;
33468 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
33470 export function InvoicePayer_pay_invoice(this_arg: number, invoice: number): number {
33471 if(!isWasmInitialized) {
33472 throw new Error("initializeWasm() must be awaited first!");
33474 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
33475 return nativeResponseValue;
33477 // 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);
33479 export function InvoicePayer_pay_zero_value_invoice(this_arg: number, invoice: number, amount_msats: bigint): number {
33480 if(!isWasmInitialized) {
33481 throw new Error("initializeWasm() must be awaited first!");
33483 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
33484 return nativeResponseValue;
33486 // 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);
33488 export function InvoicePayer_pay_pubkey(this_arg: number, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): number {
33489 if(!isWasmInitialized) {
33490 throw new Error("initializeWasm() must be awaited first!");
33492 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
33493 return nativeResponseValue;
33495 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
33497 export function InvoicePayer_remove_cached_payment(this_arg: number, payment_hash: number): void {
33498 if(!isWasmInitialized) {
33499 throw new Error("initializeWasm() must be awaited first!");
33501 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
33502 // debug statements here
33504 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
33506 export function InvoicePayer_as_EventHandler(this_arg: number): number {
33507 if(!isWasmInitialized) {
33508 throw new Error("initializeWasm() must be awaited first!");
33510 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
33511 return nativeResponseValue;
33513 // 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);
33515 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 {
33516 if(!isWasmInitialized) {
33517 throw new Error("initializeWasm() must be awaited first!");
33519 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);
33520 return nativeResponseValue;
33522 // 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);
33524 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 {
33525 if(!isWasmInitialized) {
33526 throw new Error("initializeWasm() must be awaited first!");
33528 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);
33529 return nativeResponseValue;
33531 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
33533 export function DefaultRouter_free(this_obj: number): void {
33534 if(!isWasmInitialized) {
33535 throw new Error("initializeWasm() must be awaited first!");
33537 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
33538 // debug statements here
33540 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes);
33542 export function DefaultRouter_new(network_graph: number, logger: number, random_seed_bytes: number): number {
33543 if(!isWasmInitialized) {
33544 throw new Error("initializeWasm() must be awaited first!");
33546 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes);
33547 return nativeResponseValue;
33549 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
33551 export function DefaultRouter_as_Router(this_arg: number): number {
33552 if(!isWasmInitialized) {
33553 throw new Error("initializeWasm() must be awaited first!");
33555 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
33556 return nativeResponseValue;
33558 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
33560 export function ChannelManager_as_Payer(this_arg: number): number {
33561 if(!isWasmInitialized) {
33562 throw new Error("initializeWasm() must be awaited first!");
33564 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
33565 return nativeResponseValue;
33567 // struct LDKCResult_SiPrefixParseErrorZ SiPrefix_from_str(struct LDKStr s);
33569 export function SiPrefix_from_str(s: number): number {
33570 if(!isWasmInitialized) {
33571 throw new Error("initializeWasm() must be awaited first!");
33573 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
33574 return nativeResponseValue;
33576 // struct LDKCResult_InvoiceParseOrSemanticErrorZ Invoice_from_str(struct LDKStr s);
33578 export function Invoice_from_str(s: number): number {
33579 if(!isWasmInitialized) {
33580 throw new Error("initializeWasm() must be awaited first!");
33582 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
33583 return nativeResponseValue;
33585 // struct LDKCResult_SignedRawInvoiceParseErrorZ SignedRawInvoice_from_str(struct LDKStr s);
33587 export function SignedRawInvoice_from_str(s: number): number {
33588 if(!isWasmInitialized) {
33589 throw new Error("initializeWasm() must be awaited first!");
33591 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
33592 return nativeResponseValue;
33594 // struct LDKStr ParseError_to_str(const struct LDKParseError *NONNULL_PTR o);
33596 export function ParseError_to_str(o: number): number {
33597 if(!isWasmInitialized) {
33598 throw new Error("initializeWasm() must be awaited first!");
33600 const nativeResponseValue = wasm.TS_ParseError_to_str(o);
33601 return nativeResponseValue;
33603 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
33605 export function ParseOrSemanticError_to_str(o: number): number {
33606 if(!isWasmInitialized) {
33607 throw new Error("initializeWasm() must be awaited first!");
33609 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
33610 return nativeResponseValue;
33612 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
33614 export function Invoice_to_str(o: number): number {
33615 if(!isWasmInitialized) {
33616 throw new Error("initializeWasm() must be awaited first!");
33618 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
33619 return nativeResponseValue;
33621 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
33623 export function SignedRawInvoice_to_str(o: number): number {
33624 if(!isWasmInitialized) {
33625 throw new Error("initializeWasm() must be awaited first!");
33627 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
33628 return nativeResponseValue;
33630 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
33632 export function Currency_to_str(o: number): number {
33633 if(!isWasmInitialized) {
33634 throw new Error("initializeWasm() must be awaited first!");
33636 const nativeResponseValue = wasm.TS_Currency_to_str(o);
33637 return nativeResponseValue;
33639 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
33641 export function SiPrefix_to_str(o: number): number {
33642 if(!isWasmInitialized) {
33643 throw new Error("initializeWasm() must be awaited first!");
33645 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
33646 return nativeResponseValue;
33650 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) {
33651 const weak: WeakRef<object> = js_objs[obj_ptr];
33652 if (weak == null || weak == undefined) {
33653 console.error("Got function call on unknown/free'd JS object!");
33654 throw new Error("Got function call on unknown/free'd JS object!");
33656 const obj: object = weak.deref();
33657 if (obj == null || obj == undefined) {
33658 console.error("Got function call on GC'd JS object!");
33659 throw new Error("Got function call on GC'd JS object!");
33663 case 0: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
33664 case 1: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
33665 case 2: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
33666 case 3: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
33667 case 4: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
33668 case 5: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
33669 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
33670 case 7: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
33671 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
33672 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
33673 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
33674 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
33675 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
33676 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
33677 case 14: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
33678 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33679 case 16: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
33680 case 17: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
33681 case 18: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
33682 case 19: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
33683 case 20: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
33684 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
33685 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
33686 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
33687 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
33688 case 25: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
33689 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
33690 case 27: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
33691 case 28: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
33692 case 29: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
33693 case 30: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
33694 case 31: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33695 case 32: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
33696 case 33: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
33697 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
33698 case 35: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
33699 case 36: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
33700 case 37: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
33701 case 38: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
33702 case 39: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
33703 case 40: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
33704 case 41: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
33705 case 42: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33706 case 43: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
33707 case 44: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
33708 case 45: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
33709 case 46: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
33710 case 47: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
33711 case 48: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
33712 case 49: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
33713 case 50: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
33714 case 51: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
33715 case 52: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
33716 case 53: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
33717 case 54: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
33718 case 55: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
33719 case 56: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
33720 case 57: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
33721 case 58: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
33722 case 59: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
33723 case 60: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
33724 case 61: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
33725 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
33726 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
33727 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
33728 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
33729 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
33730 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
33731 case 68: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
33732 case 69: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
33733 case 70: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
33734 case 71: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
33735 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
33736 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
33737 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
33738 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
33739 case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
33740 case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
33741 case 78: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcements"); break;
33742 case 79: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcements"); break;
33743 case 80: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
33744 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
33745 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
33746 case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
33747 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
33748 case 85: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
33749 case 86: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
33750 case 87: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
33751 case 88: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
33752 case 89: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
33753 case 90: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
33754 case 91: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
33755 case 92: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
33756 case 93: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
33757 case 94: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
33758 case 95: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
33759 case 96: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
33760 case 97: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
33761 case 98: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
33762 case 99: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
33764 console.error("Got unknown function call from C!");
33765 throw new Error("Got unknown function call from C!");
33767 if (fn == null || fn == undefined) {
33768 console.error("Got function call on incorrect JS object!");
33769 throw new Error("Got function call on incorrect JS object!");
33771 const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
33772 if (ret === undefined || ret === null) return BigInt(0);
33773 return BigInt(ret);