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 failes 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"] = js_invoke;
92 const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
93 await finishInitializeWasm(wasmInstance);
97 export async function initializeWasmFetch(uri: string) {
98 const stream = fetch(uri);
99 imports.env["js_invoke_function"] = js_invoke;
100 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
101 await finishInitializeWasm(wasmInstance);
106 export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
107 const arr = new Uint8Array(inputArray.length);
108 for (var i = 0; i < inputArray.length; i++) {
109 arr[i] = inputArray[i].getVal();
115 export function WitnessVersionArrToBytes(inputArray: Array<WitnessVersion>): Uint8Array {
116 const arr = new Uint8Array(inputArray.length);
117 for (var i = 0; i < inputArray.length; i++) {
118 arr[i] = inputArray[i].getVal();
126 export function encodeUint8Array (inputArray: Uint8Array): number {
127 const cArrayPointer = wasm.TS_malloc(inputArray.length + 4);
128 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
129 arrayLengthView[0] = inputArray.length;
130 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
131 arrayMemoryView.set(inputArray);
132 return cArrayPointer;
135 export function encodeUint32Array (inputArray: Uint32Array|Array<number>): number {
136 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 4);
137 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer, inputArray.length);
138 arrayMemoryView.set(inputArray, 1);
139 arrayMemoryView[0] = inputArray.length;
140 return cArrayPointer;
143 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>): number {
144 const cArrayPointer = wasm.TS_malloc(inputArray.length * 8 + 1);
145 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
146 arrayLengthView[0] = inputArray.length;
147 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
148 arrayMemoryView.set(inputArray);
149 return cArrayPointer;
153 export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {
154 if (arr.length != len) { throw new Error("Expected array of length " + len + "got " + arr.length); }
159 export function getArrayLength(arrayPointer: number): number {
160 const arraySizeViewer = new Uint32Array(wasm.memory.buffer, arrayPointer, 1);
161 return arraySizeViewer[0];
164 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
165 const arraySize = getArrayLength(arrayPointer);
166 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, arraySize);
167 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
168 // will free the underlying memory when it becomes unreachable instead of copying here.
169 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
170 const actualArray = actualArrayViewer.slice(0, arraySize);
172 wasm.TS_free(arrayPointer);
176 const decodeUint32Array = (arrayPointer: number, free = true) => {
177 const arraySize = getArrayLength(arrayPointer);
178 const actualArrayViewer = new Uint32Array(
179 wasm.memory.buffer, // value
180 arrayPointer + 4, // offset (ignoring length bytes)
181 arraySize // uint32 count
183 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
184 // will free the underlying memory when it becomes unreachable instead of copying here.
185 const actualArray = actualArrayViewer.slice(0, arraySize);
187 wasm.TS_free(arrayPointer);
193 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
196 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
197 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
198 return actualArrayViewer[idx];
202 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
203 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
204 return actualArrayViewer[idx];
209 export function encodeString(str: string): number {
210 const charArray = new TextEncoder().encode(str);
211 return encodeUint8Array(charArray);
215 export function decodeString(stringPointer: number, free = true): string {
216 const arraySize = getArrayLength(stringPointer);
217 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 4, arraySize);
218 const result = new TextDecoder("utf-8").decode(memoryView);
221 wasm.TS_free(stringPointer);
227 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
228 /* @internal */ export function debugPrintRemainingAllocs() { }
231 export enum AccessError {
233 * The requested chain is unknown.
235 LDKAccessError_UnknownChain,
237 * The requested transaction doesn't exist or hasn't confirmed.
239 LDKAccessError_UnknownTx,
244 export enum COption_NoneZ {
246 * When we're in this state, this COption_NoneZ contains a
248 LDKCOption_NoneZ_Some,
250 * When we're in this state, this COption_NoneZ contains nothing
252 LDKCOption_NoneZ_None,
257 export enum ChannelMonitorUpdateErr {
259 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
260 our state failed, but is expected to succeed at some point in the future).
262 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
263 submitting new commitment transactions to the counterparty. Once the update(s) that failed
264 have been successfully applied, a [`MonitorEvent::UpdateCompleted`] event should be returned
265 via [`Watch::release_pending_monitor_events`] which will then restore the channel to an
268 Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
269 you return a TemporaryFailure you must ensure that it is written to disk safely before
270 writing out the latest ChannelManager state.
272 Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
273 (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
274 to claim it on this channel) and those updates must be applied wherever they can be. At
275 least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
276 be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
277 the channel which would invalidate previous ChannelMonitors are not made when a channel has
280 Note that even if updates made after TemporaryFailure succeed you must still provide a
281 [`MonitorEvent::UpdateCompleted`] to ensure you have the latest monitor and re-enable
282 normal channel operation. Note that this is normally generated through a call to
283 [`ChainMonitor::channel_monitor_updated`].
285 Note that the update being processed here will not be replayed for you when you return a
286 [`MonitorEvent::UpdateCompleted`] event via [`Watch::release_pending_monitor_events`], so
287 you must store the update itself on your own local disk prior to returning a
288 TemporaryFailure. You may, of course, employ a journaling approach, storing only the
289 ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
292 For deployments where a copy of ChannelMonitors and other local state are backed up in a
293 remote location (with local copies persisted immediately), it is anticipated that all
294 updates will return TemporaryFailure until the remote copies could be updated.
296 [`ChainMonitor::channel_monitor_updated`]: chainmonitor::ChainMonitor::channel_monitor_updated
298 LDKChannelMonitorUpdateErr_TemporaryFailure,
300 * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
301 different watchtower and cannot update with all watchtowers that were previously informed
304 At reception of this error, ChannelManager will force-close the channel and return at
305 least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
306 least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
307 update must be rejected.
309 This failure may also signal a failure to update the local persisted copy of one of
310 the channel monitor instance.
312 Note that even when you fail a holder commitment transaction update, you must store the
313 update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
314 broadcasts it (e.g distributed channel-monitor deployment)
316 In case of distributed watchtowers deployment, the new version must be written to disk, as
317 state may have been stored but rejected due to a block forcing a commitment broadcast. This
318 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
319 lagging behind on block processing.
321 LDKChannelMonitorUpdateErr_PermanentFailure,
326 export enum ConfirmationTarget {
328 * We are happy with this transaction confirming slowly when feerate drops some.
330 LDKConfirmationTarget_Background,
332 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
334 LDKConfirmationTarget_Normal,
336 * We'd like this transaction to confirm in the next few blocks.
338 LDKConfirmationTarget_HighPriority,
343 export enum CreationError {
345 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
347 LDKCreationError_DescriptionTooLong,
349 * The specified route has too many hops and can't be encoded
351 LDKCreationError_RouteTooLong,
353 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
355 LDKCreationError_TimestampOutOfBounds,
357 * The supplied millisatoshi amount was greater than the total bitcoin supply.
359 LDKCreationError_InvalidAmount,
361 * Route hints were required for this invoice and were missing. Applies to
364 [phantom invoices]: crate::utils::create_phantom_invoice
366 LDKCreationError_MissingRouteHints,
371 export enum Currency {
379 LDKCurrency_BitcoinTestnet,
396 export enum IOError {
398 LDKIOError_PermissionDenied,
399 LDKIOError_ConnectionRefused,
400 LDKIOError_ConnectionReset,
401 LDKIOError_ConnectionAborted,
402 LDKIOError_NotConnected,
403 LDKIOError_AddrInUse,
404 LDKIOError_AddrNotAvailable,
405 LDKIOError_BrokenPipe,
406 LDKIOError_AlreadyExists,
407 LDKIOError_WouldBlock,
408 LDKIOError_InvalidInput,
409 LDKIOError_InvalidData,
411 LDKIOError_WriteZero,
412 LDKIOError_Interrupted,
414 LDKIOError_UnexpectedEof,
421 * Designates extremely verbose information, including gossip-induced messages
425 * Designates very low priority, often extremely verbose, information
429 * Designates lower priority information
433 * Designates useful information
437 * Designates hazardous situations
441 * Designates very serious errors
448 export enum Network {
450 * The main Bitcoin blockchain.
454 * The testnet3 blockchain.
458 * A local test blockchain.
462 * A blockchain on which blocks are signed instead of mined.
469 export enum Recipient {
471 * The invoice should be signed with the local node secret key.
475 * The invoice should be signed with the phantom node secret key. This secret key must be the
476 same for all nodes participating in the [phantom node payment].
478 [phantom node payment]: PhantomKeysManager
480 LDKRecipient_PhantomNode,
485 export enum Secp256k1Error {
487 * Signature failed verification
489 LDKSecp256k1Error_IncorrectSignature,
491 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
493 LDKSecp256k1Error_InvalidMessage,
497 LDKSecp256k1Error_InvalidPublicKey,
501 LDKSecp256k1Error_InvalidSignature,
505 LDKSecp256k1Error_InvalidSecretKey,
509 LDKSecp256k1Error_InvalidSharedSecret,
513 LDKSecp256k1Error_InvalidRecoveryId,
515 * Invalid tweak for add_assign or mul_assign
517 LDKSecp256k1Error_InvalidTweak,
519 * Didn't pass enough memory to context creation with preallocated memory
521 LDKSecp256k1Error_NotEnoughMemory,
523 * Bad set of public keys.
525 LDKSecp256k1Error_InvalidPublicKeySum,
527 * The only valid parity values are 0 or 1.
529 LDKSecp256k1Error_InvalidParityValue,
534 export enum SemanticError {
536 * The invoice is missing the mandatory payment hash
538 LDKSemanticError_NoPaymentHash,
540 * The invoice has multiple payment hashes which isn't allowed
542 LDKSemanticError_MultiplePaymentHashes,
544 * No description or description hash are part of the invoice
546 LDKSemanticError_NoDescription,
548 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
550 LDKSemanticError_MultipleDescriptions,
552 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
555 LDKSemanticError_NoPaymentSecret,
557 * The invoice contains multiple payment secrets
559 LDKSemanticError_MultiplePaymentSecrets,
561 * The invoice's features are invalid
563 LDKSemanticError_InvalidFeatures,
565 * The recovery id doesn't fit the signature/pub key
567 LDKSemanticError_InvalidRecoveryId,
569 * The invoice's signature is invalid
571 LDKSemanticError_InvalidSignature,
573 * The invoice's amount was not a whole number of millisatoshis
575 LDKSemanticError_ImpreciseAmount,
580 export enum SiPrefix {
600 export class LDKBech32Error {
601 protected constructor() {}
604 export function LDKBech32Error_ty_from_ptr(ptr: number): number {
605 if(!isWasmInitialized) {
606 throw new Error("initializeWasm() must be awaited first!");
608 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
609 return nativeResponseValue;
612 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: number): number {
613 if(!isWasmInitialized) {
614 throw new Error("initializeWasm() must be awaited first!");
616 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
617 return nativeResponseValue;
620 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: number): number {
621 if(!isWasmInitialized) {
622 throw new Error("initializeWasm() must be awaited first!");
624 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
625 return nativeResponseValue;
627 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
629 export function TxOut_get_script_pubkey(thing: number): number {
630 if(!isWasmInitialized) {
631 throw new Error("initializeWasm() must be awaited first!");
633 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
634 return nativeResponseValue;
636 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
638 export function TxOut_get_value(thing: number): bigint {
639 if(!isWasmInitialized) {
640 throw new Error("initializeWasm() must be awaited first!");
642 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
643 return nativeResponseValue;
645 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
647 export function CResult_NoneNoneZ_get_ok(owner: number): void {
648 if(!isWasmInitialized) {
649 throw new Error("initializeWasm() must be awaited first!");
651 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
652 // debug statements here
654 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
656 export function CResult_NoneNoneZ_get_err(owner: number): void {
657 if(!isWasmInitialized) {
658 throw new Error("initializeWasm() must be awaited first!");
660 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
661 // debug statements here
663 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
665 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: number): number {
666 if(!isWasmInitialized) {
667 throw new Error("initializeWasm() must be awaited first!");
669 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
670 return nativeResponseValue;
672 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
674 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: number): number {
675 if(!isWasmInitialized) {
676 throw new Error("initializeWasm() must be awaited first!");
678 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
679 return nativeResponseValue;
681 // struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
683 export function CResult_SecretKeyErrorZ_get_ok(owner: number): number {
684 if(!isWasmInitialized) {
685 throw new Error("initializeWasm() must be awaited first!");
687 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_ok(owner);
688 return nativeResponseValue;
690 // enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
692 export function CResult_SecretKeyErrorZ_get_err(owner: number): Secp256k1Error {
693 if(!isWasmInitialized) {
694 throw new Error("initializeWasm() must be awaited first!");
696 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_err(owner);
697 return nativeResponseValue;
699 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
701 export function CResult_PublicKeyErrorZ_get_ok(owner: number): number {
702 if(!isWasmInitialized) {
703 throw new Error("initializeWasm() must be awaited first!");
705 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
706 return nativeResponseValue;
708 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
710 export function CResult_PublicKeyErrorZ_get_err(owner: number): Secp256k1Error {
711 if(!isWasmInitialized) {
712 throw new Error("initializeWasm() must be awaited first!");
714 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
715 return nativeResponseValue;
717 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
719 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: number): number {
720 if(!isWasmInitialized) {
721 throw new Error("initializeWasm() must be awaited first!");
723 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
724 return nativeResponseValue;
726 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
728 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: number): number {
729 if(!isWasmInitialized) {
730 throw new Error("initializeWasm() must be awaited first!");
732 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
733 return nativeResponseValue;
735 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
737 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: number): number {
738 if(!isWasmInitialized) {
739 throw new Error("initializeWasm() must be awaited first!");
741 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
742 return nativeResponseValue;
744 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
746 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: number): number {
747 if(!isWasmInitialized) {
748 throw new Error("initializeWasm() must be awaited first!");
750 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
751 return nativeResponseValue;
753 // struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
755 export function CResult_TxCreationKeysErrorZ_get_ok(owner: number): number {
756 if(!isWasmInitialized) {
757 throw new Error("initializeWasm() must be awaited first!");
759 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_ok(owner);
760 return nativeResponseValue;
762 // enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
764 export function CResult_TxCreationKeysErrorZ_get_err(owner: number): Secp256k1Error {
765 if(!isWasmInitialized) {
766 throw new Error("initializeWasm() must be awaited first!");
768 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_err(owner);
769 return nativeResponseValue;
772 export class LDKCOption_u32Z {
773 protected constructor() {}
776 export function LDKCOption_u32Z_ty_from_ptr(ptr: number): number {
777 if(!isWasmInitialized) {
778 throw new Error("initializeWasm() must be awaited first!");
780 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
781 return nativeResponseValue;
784 export function LDKCOption_u32Z_Some_get_some(ptr: number): number {
785 if(!isWasmInitialized) {
786 throw new Error("initializeWasm() must be awaited first!");
788 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
789 return nativeResponseValue;
791 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
793 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: number): number {
794 if(!isWasmInitialized) {
795 throw new Error("initializeWasm() must be awaited first!");
797 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
798 return nativeResponseValue;
800 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
802 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: number): number {
803 if(!isWasmInitialized) {
804 throw new Error("initializeWasm() must be awaited first!");
806 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
807 return nativeResponseValue;
809 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
811 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
812 if(!isWasmInitialized) {
813 throw new Error("initializeWasm() must be awaited first!");
815 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
816 return nativeResponseValue;
818 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
820 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
821 if(!isWasmInitialized) {
822 throw new Error("initializeWasm() must be awaited first!");
824 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
825 return nativeResponseValue;
827 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
829 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
830 if(!isWasmInitialized) {
831 throw new Error("initializeWasm() must be awaited first!");
833 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
834 return nativeResponseValue;
836 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
838 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
839 if(!isWasmInitialized) {
840 throw new Error("initializeWasm() must be awaited first!");
842 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
843 return nativeResponseValue;
845 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
847 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
848 if(!isWasmInitialized) {
849 throw new Error("initializeWasm() must be awaited first!");
851 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
852 return nativeResponseValue;
854 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
856 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
857 if(!isWasmInitialized) {
858 throw new Error("initializeWasm() must be awaited first!");
860 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
861 return nativeResponseValue;
863 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
865 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
866 if(!isWasmInitialized) {
867 throw new Error("initializeWasm() must be awaited first!");
869 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
870 return nativeResponseValue;
872 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
874 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
875 if(!isWasmInitialized) {
876 throw new Error("initializeWasm() must be awaited first!");
878 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
879 return nativeResponseValue;
881 // struct LDKTrustedClosingTransaction *CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
883 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: number): number {
884 if(!isWasmInitialized) {
885 throw new Error("initializeWasm() must be awaited first!");
887 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
888 return nativeResponseValue;
890 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
892 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: number): void {
893 if(!isWasmInitialized) {
894 throw new Error("initializeWasm() must be awaited first!");
896 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
897 // debug statements here
899 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
901 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
902 if(!isWasmInitialized) {
903 throw new Error("initializeWasm() must be awaited first!");
905 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
906 return nativeResponseValue;
908 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
910 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
911 if(!isWasmInitialized) {
912 throw new Error("initializeWasm() must be awaited first!");
914 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
915 return nativeResponseValue;
917 // struct LDKTrustedCommitmentTransaction *CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
919 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: number): number {
920 if(!isWasmInitialized) {
921 throw new Error("initializeWasm() must be awaited first!");
923 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
924 return nativeResponseValue;
926 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
928 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: number): void {
929 if(!isWasmInitialized) {
930 throw new Error("initializeWasm() must be awaited first!");
932 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
933 // debug statements here
935 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
937 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: number): number {
938 if(!isWasmInitialized) {
939 throw new Error("initializeWasm() must be awaited first!");
941 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
942 return nativeResponseValue;
944 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
946 export function CResult_CVec_SignatureZNoneZ_get_err(owner: number): void {
947 if(!isWasmInitialized) {
948 throw new Error("initializeWasm() must be awaited first!");
950 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
951 // debug statements here
953 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
955 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: number): number {
956 if(!isWasmInitialized) {
957 throw new Error("initializeWasm() must be awaited first!");
959 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
960 return nativeResponseValue;
962 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
964 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: number): number {
965 if(!isWasmInitialized) {
966 throw new Error("initializeWasm() must be awaited first!");
968 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
969 return nativeResponseValue;
971 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
973 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: number): number {
974 if(!isWasmInitialized) {
975 throw new Error("initializeWasm() must be awaited first!");
977 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
978 return nativeResponseValue;
980 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
982 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: number): number {
983 if(!isWasmInitialized) {
984 throw new Error("initializeWasm() must be awaited first!");
986 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
987 return nativeResponseValue;
989 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
991 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: number): number {
992 if(!isWasmInitialized) {
993 throw new Error("initializeWasm() must be awaited first!");
995 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
996 return nativeResponseValue;
998 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1000 export function CResult_RouteHopDecodeErrorZ_get_err(owner: number): number {
1001 if(!isWasmInitialized) {
1002 throw new Error("initializeWasm() must be awaited first!");
1004 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
1005 return nativeResponseValue;
1007 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1009 export function CResult_RouteDecodeErrorZ_get_ok(owner: number): number {
1010 if(!isWasmInitialized) {
1011 throw new Error("initializeWasm() must be awaited first!");
1013 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
1014 return nativeResponseValue;
1016 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1018 export function CResult_RouteDecodeErrorZ_get_err(owner: number): number {
1019 if(!isWasmInitialized) {
1020 throw new Error("initializeWasm() must be awaited first!");
1022 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
1023 return nativeResponseValue;
1025 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1027 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: number): number {
1028 if(!isWasmInitialized) {
1029 throw new Error("initializeWasm() must be awaited first!");
1031 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
1032 return nativeResponseValue;
1034 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1036 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: number): number {
1037 if(!isWasmInitialized) {
1038 throw new Error("initializeWasm() must be awaited first!");
1040 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
1041 return nativeResponseValue;
1044 export class LDKCOption_u64Z {
1045 protected constructor() {}
1048 export function LDKCOption_u64Z_ty_from_ptr(ptr: number): number {
1049 if(!isWasmInitialized) {
1050 throw new Error("initializeWasm() must be awaited first!");
1052 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1053 return nativeResponseValue;
1056 export function LDKCOption_u64Z_Some_get_some(ptr: number): bigint {
1057 if(!isWasmInitialized) {
1058 throw new Error("initializeWasm() must be awaited first!");
1060 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1061 return nativeResponseValue;
1063 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1065 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: number): number {
1066 if(!isWasmInitialized) {
1067 throw new Error("initializeWasm() must be awaited first!");
1069 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
1070 return nativeResponseValue;
1072 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1074 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: number): number {
1075 if(!isWasmInitialized) {
1076 throw new Error("initializeWasm() must be awaited first!");
1078 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
1079 return nativeResponseValue;
1081 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1083 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: number): number {
1084 if(!isWasmInitialized) {
1085 throw new Error("initializeWasm() must be awaited first!");
1087 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
1088 return nativeResponseValue;
1090 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1092 export function CResult_RouteHintDecodeErrorZ_get_err(owner: number): number {
1093 if(!isWasmInitialized) {
1094 throw new Error("initializeWasm() must be awaited first!");
1096 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
1097 return nativeResponseValue;
1099 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1101 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: number): number {
1102 if(!isWasmInitialized) {
1103 throw new Error("initializeWasm() must be awaited first!");
1105 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
1106 return nativeResponseValue;
1108 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1110 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: number): number {
1111 if(!isWasmInitialized) {
1112 throw new Error("initializeWasm() must be awaited first!");
1114 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
1115 return nativeResponseValue;
1117 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1119 export function CResult_RouteLightningErrorZ_get_ok(owner: number): number {
1120 if(!isWasmInitialized) {
1121 throw new Error("initializeWasm() must be awaited first!");
1123 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
1124 return nativeResponseValue;
1126 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1128 export function CResult_RouteLightningErrorZ_get_err(owner: number): number {
1129 if(!isWasmInitialized) {
1130 throw new Error("initializeWasm() must be awaited first!");
1132 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
1133 return nativeResponseValue;
1136 export class LDKPaymentPurpose {
1137 protected constructor() {}
1140 export function LDKPaymentPurpose_ty_from_ptr(ptr: number): number {
1141 if(!isWasmInitialized) {
1142 throw new Error("initializeWasm() must be awaited first!");
1144 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1145 return nativeResponseValue;
1148 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: number): number {
1149 if(!isWasmInitialized) {
1150 throw new Error("initializeWasm() must be awaited first!");
1152 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1153 return nativeResponseValue;
1156 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: number): number {
1157 if(!isWasmInitialized) {
1158 throw new Error("initializeWasm() must be awaited first!");
1160 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1161 return nativeResponseValue;
1164 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: number): number {
1165 if(!isWasmInitialized) {
1166 throw new Error("initializeWasm() must be awaited first!");
1168 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1169 return nativeResponseValue;
1171 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1173 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: number): number {
1174 if(!isWasmInitialized) {
1175 throw new Error("initializeWasm() must be awaited first!");
1177 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
1178 return nativeResponseValue;
1180 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1182 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: number): number {
1183 if(!isWasmInitialized) {
1184 throw new Error("initializeWasm() must be awaited first!");
1186 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
1187 return nativeResponseValue;
1190 export class LDKClosureReason {
1191 protected constructor() {}
1194 export function LDKClosureReason_ty_from_ptr(ptr: number): number {
1195 if(!isWasmInitialized) {
1196 throw new Error("initializeWasm() must be awaited first!");
1198 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1199 return nativeResponseValue;
1202 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: number): number {
1203 if(!isWasmInitialized) {
1204 throw new Error("initializeWasm() must be awaited first!");
1206 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1207 return nativeResponseValue;
1210 export function LDKClosureReason_ProcessingError_get_err(ptr: number): number {
1211 if(!isWasmInitialized) {
1212 throw new Error("initializeWasm() must be awaited first!");
1214 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1215 return nativeResponseValue;
1218 export class LDKCOption_ClosureReasonZ {
1219 protected constructor() {}
1222 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: number): number {
1223 if(!isWasmInitialized) {
1224 throw new Error("initializeWasm() must be awaited first!");
1226 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
1227 return nativeResponseValue;
1230 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: number): number {
1231 if(!isWasmInitialized) {
1232 throw new Error("initializeWasm() must be awaited first!");
1234 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
1235 return nativeResponseValue;
1237 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1239 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: number): number {
1240 if(!isWasmInitialized) {
1241 throw new Error("initializeWasm() must be awaited first!");
1243 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
1244 return nativeResponseValue;
1246 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1248 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: number): number {
1249 if(!isWasmInitialized) {
1250 throw new Error("initializeWasm() must be awaited first!");
1252 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
1253 return nativeResponseValue;
1256 export class LDKNetworkUpdate {
1257 protected constructor() {}
1260 export function LDKNetworkUpdate_ty_from_ptr(ptr: number): number {
1261 if(!isWasmInitialized) {
1262 throw new Error("initializeWasm() must be awaited first!");
1264 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1265 return nativeResponseValue;
1268 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: number): number {
1269 if(!isWasmInitialized) {
1270 throw new Error("initializeWasm() must be awaited first!");
1272 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1273 return nativeResponseValue;
1276 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: number): bigint {
1277 if(!isWasmInitialized) {
1278 throw new Error("initializeWasm() must be awaited first!");
1280 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
1281 return nativeResponseValue;
1284 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: number): boolean {
1285 if(!isWasmInitialized) {
1286 throw new Error("initializeWasm() must be awaited first!");
1288 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
1289 return nativeResponseValue;
1292 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: number): number {
1293 if(!isWasmInitialized) {
1294 throw new Error("initializeWasm() must be awaited first!");
1296 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1297 return nativeResponseValue;
1300 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: number): boolean {
1301 if(!isWasmInitialized) {
1302 throw new Error("initializeWasm() must be awaited first!");
1304 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1305 return nativeResponseValue;
1308 export class LDKCOption_NetworkUpdateZ {
1309 protected constructor() {}
1312 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: number): number {
1313 if(!isWasmInitialized) {
1314 throw new Error("initializeWasm() must be awaited first!");
1316 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1317 return nativeResponseValue;
1320 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: number): number {
1321 if(!isWasmInitialized) {
1322 throw new Error("initializeWasm() must be awaited first!");
1324 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1325 return nativeResponseValue;
1328 export class LDKSpendableOutputDescriptor {
1329 protected constructor() {}
1332 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: number): number {
1333 if(!isWasmInitialized) {
1334 throw new Error("initializeWasm() must be awaited first!");
1336 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1337 return nativeResponseValue;
1340 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: number): number {
1341 if(!isWasmInitialized) {
1342 throw new Error("initializeWasm() must be awaited first!");
1344 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1345 return nativeResponseValue;
1348 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: number): number {
1349 if(!isWasmInitialized) {
1350 throw new Error("initializeWasm() must be awaited first!");
1352 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1353 return nativeResponseValue;
1356 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: number): number {
1357 if(!isWasmInitialized) {
1358 throw new Error("initializeWasm() must be awaited first!");
1360 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1361 return nativeResponseValue;
1364 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: number): number {
1365 if(!isWasmInitialized) {
1366 throw new Error("initializeWasm() must be awaited first!");
1368 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1369 return nativeResponseValue;
1372 export class LDKEvent {
1373 protected constructor() {}
1376 export function LDKEvent_ty_from_ptr(ptr: number): number {
1377 if(!isWasmInitialized) {
1378 throw new Error("initializeWasm() must be awaited first!");
1380 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1381 return nativeResponseValue;
1384 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: number): number {
1385 if(!isWasmInitialized) {
1386 throw new Error("initializeWasm() must be awaited first!");
1388 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1389 return nativeResponseValue;
1392 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: number): number {
1393 if(!isWasmInitialized) {
1394 throw new Error("initializeWasm() must be awaited first!");
1396 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
1397 return nativeResponseValue;
1400 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: number): bigint {
1401 if(!isWasmInitialized) {
1402 throw new Error("initializeWasm() must be awaited first!");
1404 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1405 return nativeResponseValue;
1408 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: number): number {
1409 if(!isWasmInitialized) {
1410 throw new Error("initializeWasm() must be awaited first!");
1412 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1413 return nativeResponseValue;
1416 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: number): bigint {
1417 if(!isWasmInitialized) {
1418 throw new Error("initializeWasm() must be awaited first!");
1420 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1421 return nativeResponseValue;
1424 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: number): number {
1425 if(!isWasmInitialized) {
1426 throw new Error("initializeWasm() must be awaited first!");
1428 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1429 return nativeResponseValue;
1432 export function LDKEvent_PaymentReceived_get_amount_msat(ptr: number): bigint {
1433 if(!isWasmInitialized) {
1434 throw new Error("initializeWasm() must be awaited first!");
1436 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amount_msat(ptr);
1437 return nativeResponseValue;
1440 export function LDKEvent_PaymentReceived_get_purpose(ptr: number): number {
1441 if(!isWasmInitialized) {
1442 throw new Error("initializeWasm() must be awaited first!");
1444 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1445 return nativeResponseValue;
1448 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: number): number {
1449 if(!isWasmInitialized) {
1450 throw new Error("initializeWasm() must be awaited first!");
1452 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
1453 return nativeResponseValue;
1456 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: number): bigint {
1457 if(!isWasmInitialized) {
1458 throw new Error("initializeWasm() must be awaited first!");
1460 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
1461 return nativeResponseValue;
1464 export function LDKEvent_PaymentClaimed_get_purpose(ptr: number): number {
1465 if(!isWasmInitialized) {
1466 throw new Error("initializeWasm() must be awaited first!");
1468 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
1469 return nativeResponseValue;
1472 export function LDKEvent_PaymentSent_get_payment_id(ptr: number): number {
1473 if(!isWasmInitialized) {
1474 throw new Error("initializeWasm() must be awaited first!");
1476 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1477 return nativeResponseValue;
1480 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: number): number {
1481 if(!isWasmInitialized) {
1482 throw new Error("initializeWasm() must be awaited first!");
1484 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1485 return nativeResponseValue;
1488 export function LDKEvent_PaymentSent_get_payment_hash(ptr: number): number {
1489 if(!isWasmInitialized) {
1490 throw new Error("initializeWasm() must be awaited first!");
1492 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1493 return nativeResponseValue;
1496 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: number): number {
1497 if(!isWasmInitialized) {
1498 throw new Error("initializeWasm() must be awaited first!");
1500 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1501 return nativeResponseValue;
1504 export function LDKEvent_PaymentFailed_get_payment_id(ptr: number): number {
1505 if(!isWasmInitialized) {
1506 throw new Error("initializeWasm() must be awaited first!");
1508 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1509 return nativeResponseValue;
1512 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: number): number {
1513 if(!isWasmInitialized) {
1514 throw new Error("initializeWasm() must be awaited first!");
1516 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1517 return nativeResponseValue;
1520 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: number): number {
1521 if(!isWasmInitialized) {
1522 throw new Error("initializeWasm() must be awaited first!");
1524 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1525 return nativeResponseValue;
1528 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: number): number {
1529 if(!isWasmInitialized) {
1530 throw new Error("initializeWasm() must be awaited first!");
1532 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1533 return nativeResponseValue;
1536 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: number): number {
1537 if(!isWasmInitialized) {
1538 throw new Error("initializeWasm() must be awaited first!");
1540 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1541 return nativeResponseValue;
1544 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: number): number {
1545 if(!isWasmInitialized) {
1546 throw new Error("initializeWasm() must be awaited first!");
1548 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1549 return nativeResponseValue;
1552 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: number): number {
1553 if(!isWasmInitialized) {
1554 throw new Error("initializeWasm() must be awaited first!");
1556 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1557 return nativeResponseValue;
1560 export function LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr: number): boolean {
1561 if(!isWasmInitialized) {
1562 throw new Error("initializeWasm() must be awaited first!");
1564 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr);
1565 return nativeResponseValue;
1568 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: number): number {
1569 if(!isWasmInitialized) {
1570 throw new Error("initializeWasm() must be awaited first!");
1572 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1573 return nativeResponseValue;
1576 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: number): boolean {
1577 if(!isWasmInitialized) {
1578 throw new Error("initializeWasm() must be awaited first!");
1580 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1581 return nativeResponseValue;
1584 export function LDKEvent_PaymentPathFailed_get_path(ptr: number): number {
1585 if(!isWasmInitialized) {
1586 throw new Error("initializeWasm() must be awaited first!");
1588 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1589 return nativeResponseValue;
1592 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: number): number {
1593 if(!isWasmInitialized) {
1594 throw new Error("initializeWasm() must be awaited first!");
1596 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1597 return nativeResponseValue;
1600 export function LDKEvent_PaymentPathFailed_get_retry(ptr: number): number {
1601 if(!isWasmInitialized) {
1602 throw new Error("initializeWasm() must be awaited first!");
1604 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1605 return nativeResponseValue;
1608 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: number): bigint {
1609 if(!isWasmInitialized) {
1610 throw new Error("initializeWasm() must be awaited first!");
1612 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1613 return nativeResponseValue;
1616 export function LDKEvent_SpendableOutputs_get_outputs(ptr: number): number {
1617 if(!isWasmInitialized) {
1618 throw new Error("initializeWasm() must be awaited first!");
1620 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1621 return nativeResponseValue;
1624 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: number): number {
1625 if(!isWasmInitialized) {
1626 throw new Error("initializeWasm() must be awaited first!");
1628 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
1629 return nativeResponseValue;
1632 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: number): number {
1633 if(!isWasmInitialized) {
1634 throw new Error("initializeWasm() must be awaited first!");
1636 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
1637 return nativeResponseValue;
1640 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: number): number {
1641 if(!isWasmInitialized) {
1642 throw new Error("initializeWasm() must be awaited first!");
1644 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1645 return nativeResponseValue;
1648 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: number): boolean {
1649 if(!isWasmInitialized) {
1650 throw new Error("initializeWasm() must be awaited first!");
1652 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1653 return nativeResponseValue;
1656 export function LDKEvent_ChannelClosed_get_channel_id(ptr: number): number {
1657 if(!isWasmInitialized) {
1658 throw new Error("initializeWasm() must be awaited first!");
1660 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1661 return nativeResponseValue;
1664 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: number): bigint {
1665 if(!isWasmInitialized) {
1666 throw new Error("initializeWasm() must be awaited first!");
1668 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1669 return nativeResponseValue;
1672 export function LDKEvent_ChannelClosed_get_reason(ptr: number): number {
1673 if(!isWasmInitialized) {
1674 throw new Error("initializeWasm() must be awaited first!");
1676 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1677 return nativeResponseValue;
1680 export function LDKEvent_DiscardFunding_get_channel_id(ptr: number): number {
1681 if(!isWasmInitialized) {
1682 throw new Error("initializeWasm() must be awaited first!");
1684 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1685 return nativeResponseValue;
1688 export function LDKEvent_DiscardFunding_get_transaction(ptr: number): number {
1689 if(!isWasmInitialized) {
1690 throw new Error("initializeWasm() must be awaited first!");
1692 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
1693 return nativeResponseValue;
1696 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: number): number {
1697 if(!isWasmInitialized) {
1698 throw new Error("initializeWasm() must be awaited first!");
1700 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
1701 return nativeResponseValue;
1704 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: number): number {
1705 if(!isWasmInitialized) {
1706 throw new Error("initializeWasm() must be awaited first!");
1708 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
1709 return nativeResponseValue;
1712 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: number): bigint {
1713 if(!isWasmInitialized) {
1714 throw new Error("initializeWasm() must be awaited first!");
1716 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
1717 return nativeResponseValue;
1720 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: number): bigint {
1721 if(!isWasmInitialized) {
1722 throw new Error("initializeWasm() must be awaited first!");
1724 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
1725 return nativeResponseValue;
1728 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: number): number {
1729 if(!isWasmInitialized) {
1730 throw new Error("initializeWasm() must be awaited first!");
1732 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
1733 return nativeResponseValue;
1736 export class LDKCOption_EventZ {
1737 protected constructor() {}
1740 export function LDKCOption_EventZ_ty_from_ptr(ptr: number): number {
1741 if(!isWasmInitialized) {
1742 throw new Error("initializeWasm() must be awaited first!");
1744 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
1745 return nativeResponseValue;
1748 export function LDKCOption_EventZ_Some_get_some(ptr: number): number {
1749 if(!isWasmInitialized) {
1750 throw new Error("initializeWasm() must be awaited first!");
1752 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
1753 return nativeResponseValue;
1755 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1757 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: number): number {
1758 if(!isWasmInitialized) {
1759 throw new Error("initializeWasm() must be awaited first!");
1761 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
1762 return nativeResponseValue;
1764 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1766 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: number): number {
1767 if(!isWasmInitialized) {
1768 throw new Error("initializeWasm() must be awaited first!");
1770 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
1771 return nativeResponseValue;
1774 export class LDKErrorAction {
1775 protected constructor() {}
1778 export function LDKErrorAction_ty_from_ptr(ptr: number): number {
1779 if(!isWasmInitialized) {
1780 throw new Error("initializeWasm() must be awaited first!");
1782 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
1783 return nativeResponseValue;
1786 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: number): number {
1787 if(!isWasmInitialized) {
1788 throw new Error("initializeWasm() must be awaited first!");
1790 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
1791 return nativeResponseValue;
1794 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: number): Level {
1795 if(!isWasmInitialized) {
1796 throw new Error("initializeWasm() must be awaited first!");
1798 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
1799 return nativeResponseValue;
1802 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: number): number {
1803 if(!isWasmInitialized) {
1804 throw new Error("initializeWasm() must be awaited first!");
1806 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
1807 return nativeResponseValue;
1810 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: number): number {
1811 if(!isWasmInitialized) {
1812 throw new Error("initializeWasm() must be awaited first!");
1814 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
1815 return nativeResponseValue;
1818 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: number): Level {
1819 if(!isWasmInitialized) {
1820 throw new Error("initializeWasm() must be awaited first!");
1822 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
1823 return nativeResponseValue;
1826 export class LDKMessageSendEvent {
1827 protected constructor() {}
1830 export function LDKMessageSendEvent_ty_from_ptr(ptr: number): number {
1831 if(!isWasmInitialized) {
1832 throw new Error("initializeWasm() must be awaited first!");
1834 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
1835 return nativeResponseValue;
1838 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: number): number {
1839 if(!isWasmInitialized) {
1840 throw new Error("initializeWasm() must be awaited first!");
1842 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
1843 return nativeResponseValue;
1846 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: number): number {
1847 if(!isWasmInitialized) {
1848 throw new Error("initializeWasm() must be awaited first!");
1850 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
1851 return nativeResponseValue;
1854 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: number): number {
1855 if(!isWasmInitialized) {
1856 throw new Error("initializeWasm() must be awaited first!");
1858 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
1859 return nativeResponseValue;
1862 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: number): number {
1863 if(!isWasmInitialized) {
1864 throw new Error("initializeWasm() must be awaited first!");
1866 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
1867 return nativeResponseValue;
1870 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: number): number {
1871 if(!isWasmInitialized) {
1872 throw new Error("initializeWasm() must be awaited first!");
1874 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
1875 return nativeResponseValue;
1878 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: number): number {
1879 if(!isWasmInitialized) {
1880 throw new Error("initializeWasm() must be awaited first!");
1882 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
1883 return nativeResponseValue;
1886 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: number): number {
1887 if(!isWasmInitialized) {
1888 throw new Error("initializeWasm() must be awaited first!");
1890 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
1891 return nativeResponseValue;
1894 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: number): number {
1895 if(!isWasmInitialized) {
1896 throw new Error("initializeWasm() must be awaited first!");
1898 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
1899 return nativeResponseValue;
1902 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: number): number {
1903 if(!isWasmInitialized) {
1904 throw new Error("initializeWasm() must be awaited first!");
1906 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
1907 return nativeResponseValue;
1910 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: number): number {
1911 if(!isWasmInitialized) {
1912 throw new Error("initializeWasm() must be awaited first!");
1914 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
1915 return nativeResponseValue;
1918 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: number): number {
1919 if(!isWasmInitialized) {
1920 throw new Error("initializeWasm() must be awaited first!");
1922 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
1923 return nativeResponseValue;
1926 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: number): number {
1927 if(!isWasmInitialized) {
1928 throw new Error("initializeWasm() must be awaited first!");
1930 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
1931 return nativeResponseValue;
1934 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: number): number {
1935 if(!isWasmInitialized) {
1936 throw new Error("initializeWasm() must be awaited first!");
1938 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
1939 return nativeResponseValue;
1942 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: number): number {
1943 if(!isWasmInitialized) {
1944 throw new Error("initializeWasm() must be awaited first!");
1946 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
1947 return nativeResponseValue;
1950 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: number): number {
1951 if(!isWasmInitialized) {
1952 throw new Error("initializeWasm() must be awaited first!");
1954 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
1955 return nativeResponseValue;
1958 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: number): number {
1959 if(!isWasmInitialized) {
1960 throw new Error("initializeWasm() must be awaited first!");
1962 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
1963 return nativeResponseValue;
1966 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: number): number {
1967 if(!isWasmInitialized) {
1968 throw new Error("initializeWasm() must be awaited first!");
1970 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
1971 return nativeResponseValue;
1974 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: number): number {
1975 if(!isWasmInitialized) {
1976 throw new Error("initializeWasm() must be awaited first!");
1978 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
1979 return nativeResponseValue;
1982 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: number): number {
1983 if(!isWasmInitialized) {
1984 throw new Error("initializeWasm() must be awaited first!");
1986 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
1987 return nativeResponseValue;
1990 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: number): number {
1991 if(!isWasmInitialized) {
1992 throw new Error("initializeWasm() must be awaited first!");
1994 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
1995 return nativeResponseValue;
1998 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: number): number {
1999 if(!isWasmInitialized) {
2000 throw new Error("initializeWasm() must be awaited first!");
2002 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2003 return nativeResponseValue;
2006 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: number): number {
2007 if(!isWasmInitialized) {
2008 throw new Error("initializeWasm() must be awaited first!");
2010 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2011 return nativeResponseValue;
2014 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: number): number {
2015 if(!isWasmInitialized) {
2016 throw new Error("initializeWasm() must be awaited first!");
2018 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2019 return nativeResponseValue;
2022 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: number): number {
2023 if(!isWasmInitialized) {
2024 throw new Error("initializeWasm() must be awaited first!");
2026 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2027 return nativeResponseValue;
2030 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: number): number {
2031 if(!isWasmInitialized) {
2032 throw new Error("initializeWasm() must be awaited first!");
2034 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
2035 return nativeResponseValue;
2038 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: number): number {
2039 if(!isWasmInitialized) {
2040 throw new Error("initializeWasm() must be awaited first!");
2042 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2043 return nativeResponseValue;
2046 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: number): number {
2047 if(!isWasmInitialized) {
2048 throw new Error("initializeWasm() must be awaited first!");
2050 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2051 return nativeResponseValue;
2054 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: number): number {
2055 if(!isWasmInitialized) {
2056 throw new Error("initializeWasm() must be awaited first!");
2058 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2059 return nativeResponseValue;
2062 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: number): number {
2063 if(!isWasmInitialized) {
2064 throw new Error("initializeWasm() must be awaited first!");
2066 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2067 return nativeResponseValue;
2070 export function LDKMessageSendEvent_HandleError_get_action(ptr: number): number {
2071 if(!isWasmInitialized) {
2072 throw new Error("initializeWasm() must be awaited first!");
2074 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2075 return nativeResponseValue;
2078 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: number): number {
2079 if(!isWasmInitialized) {
2080 throw new Error("initializeWasm() must be awaited first!");
2082 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2083 return nativeResponseValue;
2086 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: number): number {
2087 if(!isWasmInitialized) {
2088 throw new Error("initializeWasm() must be awaited first!");
2090 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2091 return nativeResponseValue;
2094 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: number): number {
2095 if(!isWasmInitialized) {
2096 throw new Error("initializeWasm() must be awaited first!");
2098 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2099 return nativeResponseValue;
2102 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: number): number {
2103 if(!isWasmInitialized) {
2104 throw new Error("initializeWasm() must be awaited first!");
2106 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2107 return nativeResponseValue;
2110 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: number): number {
2111 if(!isWasmInitialized) {
2112 throw new Error("initializeWasm() must be awaited first!");
2114 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2115 return nativeResponseValue;
2118 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: number): number {
2119 if(!isWasmInitialized) {
2120 throw new Error("initializeWasm() must be awaited first!");
2122 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2123 return nativeResponseValue;
2126 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: number): number {
2127 if(!isWasmInitialized) {
2128 throw new Error("initializeWasm() must be awaited first!");
2130 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
2131 return nativeResponseValue;
2134 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: number): number {
2135 if(!isWasmInitialized) {
2136 throw new Error("initializeWasm() must be awaited first!");
2138 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
2139 return nativeResponseValue;
2141 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2143 export function CResult_TxOutAccessErrorZ_get_ok(owner: number): number {
2144 if(!isWasmInitialized) {
2145 throw new Error("initializeWasm() must be awaited first!");
2147 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
2148 return nativeResponseValue;
2150 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2152 export function CResult_TxOutAccessErrorZ_get_err(owner: number): AccessError {
2153 if(!isWasmInitialized) {
2154 throw new Error("initializeWasm() must be awaited first!");
2156 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
2157 return nativeResponseValue;
2159 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2161 export function C2Tuple_usizeTransactionZ_get_a(owner: number): number {
2162 if(!isWasmInitialized) {
2163 throw new Error("initializeWasm() must be awaited first!");
2165 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2166 return nativeResponseValue;
2168 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2170 export function C2Tuple_usizeTransactionZ_get_b(owner: number): number {
2171 if(!isWasmInitialized) {
2172 throw new Error("initializeWasm() must be awaited first!");
2174 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2175 return nativeResponseValue;
2177 // void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2179 export function CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner: number): void {
2180 if(!isWasmInitialized) {
2181 throw new Error("initializeWasm() must be awaited first!");
2183 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner);
2184 // debug statements here
2186 // enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2188 export function CResult_NoneChannelMonitorUpdateErrZ_get_err(owner: number): ChannelMonitorUpdateErr {
2189 if(!isWasmInitialized) {
2190 throw new Error("initializeWasm() must be awaited first!");
2192 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(owner);
2193 return nativeResponseValue;
2196 export class LDKMonitorEvent {
2197 protected constructor() {}
2200 export function LDKMonitorEvent_ty_from_ptr(ptr: number): number {
2201 if(!isWasmInitialized) {
2202 throw new Error("initializeWasm() must be awaited first!");
2204 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2205 return nativeResponseValue;
2208 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: number): number {
2209 if(!isWasmInitialized) {
2210 throw new Error("initializeWasm() must be awaited first!");
2212 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2213 return nativeResponseValue;
2216 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: number): number {
2217 if(!isWasmInitialized) {
2218 throw new Error("initializeWasm() must be awaited first!");
2220 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
2221 return nativeResponseValue;
2224 export function LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr: number): number {
2225 if(!isWasmInitialized) {
2226 throw new Error("initializeWasm() must be awaited first!");
2228 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr);
2229 return nativeResponseValue;
2232 export function LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr: number): bigint {
2233 if(!isWasmInitialized) {
2234 throw new Error("initializeWasm() must be awaited first!");
2236 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr);
2237 return nativeResponseValue;
2240 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: number): number {
2241 if(!isWasmInitialized) {
2242 throw new Error("initializeWasm() must be awaited first!");
2244 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
2245 return nativeResponseValue;
2247 // struct LDKOutPoint C2Tuple_OutPointCVec_MonitorEventZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR owner);
2249 export function C2Tuple_OutPointCVec_MonitorEventZZ_get_a(owner: number): number {
2250 if(!isWasmInitialized) {
2251 throw new Error("initializeWasm() must be awaited first!");
2253 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_get_a(owner);
2254 return nativeResponseValue;
2256 // struct LDKCVec_MonitorEventZ C2Tuple_OutPointCVec_MonitorEventZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR owner);
2258 export function C2Tuple_OutPointCVec_MonitorEventZZ_get_b(owner: number): number {
2259 if(!isWasmInitialized) {
2260 throw new Error("initializeWasm() must be awaited first!");
2262 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_get_b(owner);
2263 return nativeResponseValue;
2266 export class LDKCOption_C2Tuple_usizeTransactionZZ {
2267 protected constructor() {}
2270 export function LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr: number): number {
2271 if(!isWasmInitialized) {
2272 throw new Error("initializeWasm() must be awaited first!");
2274 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr);
2275 return nativeResponseValue;
2278 export function LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr: number): number {
2279 if(!isWasmInitialized) {
2280 throw new Error("initializeWasm() must be awaited first!");
2282 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr);
2283 return nativeResponseValue;
2285 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2287 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: number): number {
2288 if(!isWasmInitialized) {
2289 throw new Error("initializeWasm() must be awaited first!");
2291 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2292 return nativeResponseValue;
2294 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2296 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: number): number {
2297 if(!isWasmInitialized) {
2298 throw new Error("initializeWasm() must be awaited first!");
2300 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2301 return nativeResponseValue;
2304 export interface LDKLogger {
2305 log (record: number): void;
2309 export function LDKLogger_new(impl: LDKLogger): number {
2310 if(!isWasmInitialized) {
2311 throw new Error("initializeWasm() must be awaited first!");
2313 var new_obj_idx = js_objs.length;
2314 for (var i = 0; i < js_objs.length; i++) {
2315 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2317 js_objs[i] = new WeakRef(impl);
2318 return wasm.TS_LDKLogger_new(i);
2320 // struct LDKProbabilisticScorer *CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2322 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: number): number {
2323 if(!isWasmInitialized) {
2324 throw new Error("initializeWasm() must be awaited first!");
2326 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2327 return nativeResponseValue;
2329 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2331 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: number): number {
2332 if(!isWasmInitialized) {
2333 throw new Error("initializeWasm() must be awaited first!");
2335 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2336 return nativeResponseValue;
2338 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2340 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: number): number {
2341 if(!isWasmInitialized) {
2342 throw new Error("initializeWasm() must be awaited first!");
2344 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2345 return nativeResponseValue;
2347 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2349 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: number): number {
2350 if(!isWasmInitialized) {
2351 throw new Error("initializeWasm() must be awaited first!");
2353 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2354 return nativeResponseValue;
2356 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2358 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: number): number {
2359 if(!isWasmInitialized) {
2360 throw new Error("initializeWasm() must be awaited first!");
2362 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2363 return nativeResponseValue;
2365 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2367 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: number): number {
2368 if(!isWasmInitialized) {
2369 throw new Error("initializeWasm() must be awaited first!");
2371 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2372 return nativeResponseValue;
2374 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2376 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2377 if(!isWasmInitialized) {
2378 throw new Error("initializeWasm() must be awaited first!");
2380 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2381 return nativeResponseValue;
2383 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2385 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: number): number {
2386 if(!isWasmInitialized) {
2387 throw new Error("initializeWasm() must be awaited first!");
2389 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2390 return nativeResponseValue;
2392 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2394 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: number): number {
2395 if(!isWasmInitialized) {
2396 throw new Error("initializeWasm() must be awaited first!");
2398 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2399 return nativeResponseValue;
2401 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2403 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: number): number {
2404 if(!isWasmInitialized) {
2405 throw new Error("initializeWasm() must be awaited first!");
2407 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2408 return nativeResponseValue;
2410 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2412 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2413 if(!isWasmInitialized) {
2414 throw new Error("initializeWasm() must be awaited first!");
2416 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2417 return nativeResponseValue;
2419 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2421 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: number): number {
2422 if(!isWasmInitialized) {
2423 throw new Error("initializeWasm() must be awaited first!");
2425 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2426 return nativeResponseValue;
2428 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2430 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: number): number {
2431 if(!isWasmInitialized) {
2432 throw new Error("initializeWasm() must be awaited first!");
2434 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2435 return nativeResponseValue;
2437 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2439 export function CResult_NodeIdDecodeErrorZ_get_err(owner: number): number {
2440 if(!isWasmInitialized) {
2441 throw new Error("initializeWasm() must be awaited first!");
2443 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2444 return nativeResponseValue;
2446 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2448 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: number): number {
2449 if(!isWasmInitialized) {
2450 throw new Error("initializeWasm() must be awaited first!");
2452 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2453 return nativeResponseValue;
2455 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2457 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: number): number {
2458 if(!isWasmInitialized) {
2459 throw new Error("initializeWasm() must be awaited first!");
2461 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2462 return nativeResponseValue;
2465 export interface LDKAccess {
2466 get_utxo (genesis_hash: number, short_channel_id: bigint): number;
2470 export function LDKAccess_new(impl: LDKAccess): number {
2471 if(!isWasmInitialized) {
2472 throw new Error("initializeWasm() must be awaited first!");
2474 var new_obj_idx = js_objs.length;
2475 for (var i = 0; i < js_objs.length; i++) {
2476 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2478 js_objs[i] = new WeakRef(impl);
2479 return wasm.TS_LDKAccess_new(i);
2481 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
2483 export function Access_get_utxo(this_arg: number, genesis_hash: number, short_channel_id: bigint): number {
2484 if(!isWasmInitialized) {
2485 throw new Error("initializeWasm() must be awaited first!");
2487 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
2488 return nativeResponseValue;
2491 export class LDKCOption_AccessZ {
2492 protected constructor() {}
2495 export function LDKCOption_AccessZ_ty_from_ptr(ptr: number): number {
2496 if(!isWasmInitialized) {
2497 throw new Error("initializeWasm() must be awaited first!");
2499 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
2500 return nativeResponseValue;
2503 export function LDKCOption_AccessZ_Some_get_some(ptr: number): number {
2504 if(!isWasmInitialized) {
2505 throw new Error("initializeWasm() must be awaited first!");
2507 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
2508 return nativeResponseValue;
2510 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2512 export function CResult_boolLightningErrorZ_get_ok(owner: number): boolean {
2513 if(!isWasmInitialized) {
2514 throw new Error("initializeWasm() must be awaited first!");
2516 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
2517 return nativeResponseValue;
2519 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2521 export function CResult_boolLightningErrorZ_get_err(owner: number): number {
2522 if(!isWasmInitialized) {
2523 throw new Error("initializeWasm() must be awaited first!");
2525 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
2526 return nativeResponseValue;
2528 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2530 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: number): number {
2531 if(!isWasmInitialized) {
2532 throw new Error("initializeWasm() must be awaited first!");
2534 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
2535 return nativeResponseValue;
2537 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2539 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: number): number {
2540 if(!isWasmInitialized) {
2541 throw new Error("initializeWasm() must be awaited first!");
2543 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
2544 return nativeResponseValue;
2546 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2548 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: number): number {
2549 if(!isWasmInitialized) {
2550 throw new Error("initializeWasm() must be awaited first!");
2552 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
2553 return nativeResponseValue;
2555 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2557 export function CResult_NoneLightningErrorZ_get_ok(owner: number): void {
2558 if(!isWasmInitialized) {
2559 throw new Error("initializeWasm() must be awaited first!");
2561 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
2562 // debug statements here
2564 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2566 export function CResult_NoneLightningErrorZ_get_err(owner: number): number {
2567 if(!isWasmInitialized) {
2568 throw new Error("initializeWasm() must be awaited first!");
2570 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
2571 return nativeResponseValue;
2573 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2575 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: number): number {
2576 if(!isWasmInitialized) {
2577 throw new Error("initializeWasm() must be awaited first!");
2579 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
2580 return nativeResponseValue;
2582 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2584 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: number): number {
2585 if(!isWasmInitialized) {
2586 throw new Error("initializeWasm() must be awaited first!");
2588 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
2589 return nativeResponseValue;
2591 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2593 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: number): number {
2594 if(!isWasmInitialized) {
2595 throw new Error("initializeWasm() must be awaited first!");
2597 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
2598 return nativeResponseValue;
2600 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2602 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: number): number {
2603 if(!isWasmInitialized) {
2604 throw new Error("initializeWasm() must be awaited first!");
2606 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
2607 return nativeResponseValue;
2609 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2611 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: number): number {
2612 if(!isWasmInitialized) {
2613 throw new Error("initializeWasm() must be awaited first!");
2615 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
2616 return nativeResponseValue;
2618 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2620 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: number): number {
2621 if(!isWasmInitialized) {
2622 throw new Error("initializeWasm() must be awaited first!");
2624 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
2625 return nativeResponseValue;
2628 export class LDKNetAddress {
2629 protected constructor() {}
2632 export function LDKNetAddress_ty_from_ptr(ptr: number): number {
2633 if(!isWasmInitialized) {
2634 throw new Error("initializeWasm() must be awaited first!");
2636 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
2637 return nativeResponseValue;
2640 export function LDKNetAddress_IPv4_get_addr(ptr: number): number {
2641 if(!isWasmInitialized) {
2642 throw new Error("initializeWasm() must be awaited first!");
2644 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
2645 return nativeResponseValue;
2648 export function LDKNetAddress_IPv4_get_port(ptr: number): number {
2649 if(!isWasmInitialized) {
2650 throw new Error("initializeWasm() must be awaited first!");
2652 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
2653 return nativeResponseValue;
2656 export function LDKNetAddress_IPv6_get_addr(ptr: number): number {
2657 if(!isWasmInitialized) {
2658 throw new Error("initializeWasm() must be awaited first!");
2660 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
2661 return nativeResponseValue;
2664 export function LDKNetAddress_IPv6_get_port(ptr: number): number {
2665 if(!isWasmInitialized) {
2666 throw new Error("initializeWasm() must be awaited first!");
2668 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
2669 return nativeResponseValue;
2672 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: number): number {
2673 if(!isWasmInitialized) {
2674 throw new Error("initializeWasm() must be awaited first!");
2676 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
2677 return nativeResponseValue;
2680 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: number): number {
2681 if(!isWasmInitialized) {
2682 throw new Error("initializeWasm() must be awaited first!");
2684 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
2685 return nativeResponseValue;
2688 export function LDKNetAddress_OnionV3_get_checksum(ptr: number): number {
2689 if(!isWasmInitialized) {
2690 throw new Error("initializeWasm() must be awaited first!");
2692 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
2693 return nativeResponseValue;
2696 export function LDKNetAddress_OnionV3_get_version(ptr: number): number {
2697 if(!isWasmInitialized) {
2698 throw new Error("initializeWasm() must be awaited first!");
2700 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
2701 return nativeResponseValue;
2704 export function LDKNetAddress_OnionV3_get_port(ptr: number): number {
2705 if(!isWasmInitialized) {
2706 throw new Error("initializeWasm() must be awaited first!");
2708 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
2709 return nativeResponseValue;
2711 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2713 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: number): number {
2714 if(!isWasmInitialized) {
2715 throw new Error("initializeWasm() must be awaited first!");
2717 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
2718 return nativeResponseValue;
2720 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2722 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: number): number {
2723 if(!isWasmInitialized) {
2724 throw new Error("initializeWasm() must be awaited first!");
2726 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
2727 return nativeResponseValue;
2729 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2731 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: number): number {
2732 if(!isWasmInitialized) {
2733 throw new Error("initializeWasm() must be awaited first!");
2735 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
2736 return nativeResponseValue;
2738 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2740 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: number): number {
2741 if(!isWasmInitialized) {
2742 throw new Error("initializeWasm() must be awaited first!");
2744 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
2745 return nativeResponseValue;
2747 // struct LDKNetworkGraph *CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
2749 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: number): number {
2750 if(!isWasmInitialized) {
2751 throw new Error("initializeWasm() must be awaited first!");
2753 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
2754 return nativeResponseValue;
2756 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
2758 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: number): number {
2759 if(!isWasmInitialized) {
2760 throw new Error("initializeWasm() must be awaited first!");
2762 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
2763 return nativeResponseValue;
2766 export class LDKCOption_CVec_NetAddressZZ {
2767 protected constructor() {}
2770 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: number): number {
2771 if(!isWasmInitialized) {
2772 throw new Error("initializeWasm() must be awaited first!");
2774 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
2775 return nativeResponseValue;
2778 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: number): number {
2779 if(!isWasmInitialized) {
2780 throw new Error("initializeWasm() must be awaited first!");
2782 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
2783 return nativeResponseValue;
2785 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2787 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2788 if(!isWasmInitialized) {
2789 throw new Error("initializeWasm() must be awaited first!");
2791 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2792 return nativeResponseValue;
2794 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2796 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2797 if(!isWasmInitialized) {
2798 throw new Error("initializeWasm() must be awaited first!");
2800 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2801 return nativeResponseValue;
2803 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2805 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2806 if(!isWasmInitialized) {
2807 throw new Error("initializeWasm() must be awaited first!");
2809 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2810 return nativeResponseValue;
2812 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2814 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2815 if(!isWasmInitialized) {
2816 throw new Error("initializeWasm() must be awaited first!");
2818 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2819 return nativeResponseValue;
2821 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2823 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2824 if(!isWasmInitialized) {
2825 throw new Error("initializeWasm() must be awaited first!");
2827 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
2828 return nativeResponseValue;
2830 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2832 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2833 if(!isWasmInitialized) {
2834 throw new Error("initializeWasm() must be awaited first!");
2836 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
2837 return nativeResponseValue;
2839 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2841 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: number): number {
2842 if(!isWasmInitialized) {
2843 throw new Error("initializeWasm() must be awaited first!");
2845 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
2846 return nativeResponseValue;
2848 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2850 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: number): number {
2851 if(!isWasmInitialized) {
2852 throw new Error("initializeWasm() must be awaited first!");
2854 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
2855 return nativeResponseValue;
2857 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2859 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: number): number {
2860 if(!isWasmInitialized) {
2861 throw new Error("initializeWasm() must be awaited first!");
2863 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
2864 return nativeResponseValue;
2866 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2868 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: number): void {
2869 if(!isWasmInitialized) {
2870 throw new Error("initializeWasm() must be awaited first!");
2872 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
2873 // debug statements here
2875 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2877 export function CResult_SignatureNoneZ_get_ok(owner: number): number {
2878 if(!isWasmInitialized) {
2879 throw new Error("initializeWasm() must be awaited first!");
2881 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
2882 return nativeResponseValue;
2884 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2886 export function CResult_SignatureNoneZ_get_err(owner: number): void {
2887 if(!isWasmInitialized) {
2888 throw new Error("initializeWasm() must be awaited first!");
2890 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
2891 // debug statements here
2893 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2895 export function C2Tuple_SignatureSignatureZ_get_a(owner: number): number {
2896 if(!isWasmInitialized) {
2897 throw new Error("initializeWasm() must be awaited first!");
2899 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
2900 return nativeResponseValue;
2902 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2904 export function C2Tuple_SignatureSignatureZ_get_b(owner: number): number {
2905 if(!isWasmInitialized) {
2906 throw new Error("initializeWasm() must be awaited first!");
2908 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
2909 return nativeResponseValue;
2911 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
2913 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: number): number {
2914 if(!isWasmInitialized) {
2915 throw new Error("initializeWasm() must be awaited first!");
2917 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
2918 return nativeResponseValue;
2920 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
2922 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: number): void {
2923 if(!isWasmInitialized) {
2924 throw new Error("initializeWasm() must be awaited first!");
2926 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
2927 // debug statements here
2929 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
2931 export function CResult_SecretKeyNoneZ_get_ok(owner: number): number {
2932 if(!isWasmInitialized) {
2933 throw new Error("initializeWasm() must be awaited first!");
2935 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
2936 return nativeResponseValue;
2938 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
2940 export function CResult_SecretKeyNoneZ_get_err(owner: number): void {
2941 if(!isWasmInitialized) {
2942 throw new Error("initializeWasm() must be awaited first!");
2944 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
2945 // debug statements here
2948 export interface LDKBaseSign {
2949 get_per_commitment_point (idx: bigint): number;
2950 release_commitment_secret (idx: bigint): number;
2951 validate_holder_commitment (holder_tx: number, preimages: number): number;
2952 channel_keys_id (): number;
2953 sign_counterparty_commitment (commitment_tx: number, preimages: number): number;
2954 validate_counterparty_revocation (idx: bigint, secret: number): number;
2955 sign_holder_commitment_and_htlcs (commitment_tx: number): number;
2956 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number;
2957 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number;
2958 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number;
2959 sign_closing_transaction (closing_tx: number): number;
2960 sign_channel_announcement (msg: number): number;
2961 ready_channel (channel_parameters: number): void;
2965 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: number): number {
2966 if(!isWasmInitialized) {
2967 throw new Error("initializeWasm() must be awaited first!");
2969 var new_obj_idx = js_objs.length;
2970 for (var i = 0; i < js_objs.length; i++) {
2971 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2973 js_objs[i] = new WeakRef(impl);
2974 return wasm.TS_LDKBaseSign_new(i);
2976 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
2978 export function BaseSign_get_per_commitment_point(this_arg: number, idx: bigint): number {
2979 if(!isWasmInitialized) {
2980 throw new Error("initializeWasm() must be awaited first!");
2982 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
2983 return nativeResponseValue;
2985 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
2987 export function BaseSign_release_commitment_secret(this_arg: number, idx: bigint): number {
2988 if(!isWasmInitialized) {
2989 throw new Error("initializeWasm() must be awaited first!");
2991 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
2992 return nativeResponseValue;
2994 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
2996 export function BaseSign_validate_holder_commitment(this_arg: number, holder_tx: number, preimages: number): number {
2997 if(!isWasmInitialized) {
2998 throw new Error("initializeWasm() must be awaited first!");
3000 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
3001 return nativeResponseValue;
3003 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
3005 export function BaseSign_channel_keys_id(this_arg: number): number {
3006 if(!isWasmInitialized) {
3007 throw new Error("initializeWasm() must be awaited first!");
3009 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
3010 return nativeResponseValue;
3012 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
3014 export function BaseSign_sign_counterparty_commitment(this_arg: number, commitment_tx: number, preimages: number): number {
3015 if(!isWasmInitialized) {
3016 throw new Error("initializeWasm() must be awaited first!");
3018 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
3019 return nativeResponseValue;
3021 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
3023 export function BaseSign_validate_counterparty_revocation(this_arg: number, idx: bigint, secret: number): number {
3024 if(!isWasmInitialized) {
3025 throw new Error("initializeWasm() must be awaited first!");
3027 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
3028 return nativeResponseValue;
3030 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
3032 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
3033 if(!isWasmInitialized) {
3034 throw new Error("initializeWasm() must be awaited first!");
3036 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
3037 return nativeResponseValue;
3039 // 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]
3041 export function BaseSign_sign_justice_revoked_output(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number {
3042 if(!isWasmInitialized) {
3043 throw new Error("initializeWasm() must be awaited first!");
3045 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
3046 return nativeResponseValue;
3048 // 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
3050 export function BaseSign_sign_justice_revoked_htlc(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number {
3051 if(!isWasmInitialized) {
3052 throw new Error("initializeWasm() must be awaited first!");
3054 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
3055 return nativeResponseValue;
3057 // 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
3059 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number {
3060 if(!isWasmInitialized) {
3061 throw new Error("initializeWasm() must be awaited first!");
3063 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
3064 return nativeResponseValue;
3066 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
3068 export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: number): number {
3069 if(!isWasmInitialized) {
3070 throw new Error("initializeWasm() must be awaited first!");
3072 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
3073 return nativeResponseValue;
3075 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
3077 export function BaseSign_sign_channel_announcement(this_arg: number, msg: number): number {
3078 if(!isWasmInitialized) {
3079 throw new Error("initializeWasm() must be awaited first!");
3081 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
3082 return nativeResponseValue;
3084 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
3086 export function BaseSign_ready_channel(this_arg: number, channel_parameters: number): void {
3087 if(!isWasmInitialized) {
3088 throw new Error("initializeWasm() must be awaited first!");
3090 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
3091 // debug statements here
3093 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
3095 export function BaseSign_get_pubkeys(this_arg: number): number {
3096 if(!isWasmInitialized) {
3097 throw new Error("initializeWasm() must be awaited first!");
3099 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
3100 return nativeResponseValue;
3103 export interface LDKSign {
3108 export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: number): number {
3109 if(!isWasmInitialized) {
3110 throw new Error("initializeWasm() must be awaited first!");
3112 var new_obj_idx = js_objs.length;
3113 for (var i = 0; i < js_objs.length; i++) {
3114 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3116 js_objs[i] = new WeakRef(impl);
3117 return wasm.TS_LDKSign_new(i);
3119 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
3121 export function Sign_write(this_arg: number): number {
3122 if(!isWasmInitialized) {
3123 throw new Error("initializeWasm() must be awaited first!");
3125 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
3126 return nativeResponseValue;
3128 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3130 export function CResult_SignDecodeErrorZ_get_ok(owner: number): number {
3131 if(!isWasmInitialized) {
3132 throw new Error("initializeWasm() must be awaited first!");
3134 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
3135 return nativeResponseValue;
3137 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3139 export function CResult_SignDecodeErrorZ_get_err(owner: number): number {
3140 if(!isWasmInitialized) {
3141 throw new Error("initializeWasm() must be awaited first!");
3143 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
3144 return nativeResponseValue;
3146 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3148 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: number): number {
3149 if(!isWasmInitialized) {
3150 throw new Error("initializeWasm() must be awaited first!");
3152 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3153 return nativeResponseValue;
3155 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3157 export function CResult_RecoverableSignatureNoneZ_get_err(owner: number): void {
3158 if(!isWasmInitialized) {
3159 throw new Error("initializeWasm() must be awaited first!");
3161 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3162 // debug statements here
3164 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3166 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: number): number {
3167 if(!isWasmInitialized) {
3168 throw new Error("initializeWasm() must be awaited first!");
3170 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
3171 return nativeResponseValue;
3173 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3175 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: number): void {
3176 if(!isWasmInitialized) {
3177 throw new Error("initializeWasm() must be awaited first!");
3179 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
3180 // debug statements here
3182 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3184 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: number): number {
3185 if(!isWasmInitialized) {
3186 throw new Error("initializeWasm() must be awaited first!");
3188 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
3189 return nativeResponseValue;
3191 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3193 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: number): number {
3194 if(!isWasmInitialized) {
3195 throw new Error("initializeWasm() must be awaited first!");
3197 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
3198 return nativeResponseValue;
3200 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3202 export function CResult_TransactionNoneZ_get_ok(owner: number): number {
3203 if(!isWasmInitialized) {
3204 throw new Error("initializeWasm() must be awaited first!");
3206 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
3207 return nativeResponseValue;
3209 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3211 export function CResult_TransactionNoneZ_get_err(owner: number): void {
3212 if(!isWasmInitialized) {
3213 throw new Error("initializeWasm() must be awaited first!");
3215 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
3216 // debug statements here
3219 export class LDKCOption_u16Z {
3220 protected constructor() {}
3223 export function LDKCOption_u16Z_ty_from_ptr(ptr: number): number {
3224 if(!isWasmInitialized) {
3225 throw new Error("initializeWasm() must be awaited first!");
3227 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
3228 return nativeResponseValue;
3231 export function LDKCOption_u16Z_Some_get_some(ptr: number): number {
3232 if(!isWasmInitialized) {
3233 throw new Error("initializeWasm() must be awaited first!");
3235 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
3236 return nativeResponseValue;
3239 export class LDKAPIError {
3240 protected constructor() {}
3243 export function LDKAPIError_ty_from_ptr(ptr: number): number {
3244 if(!isWasmInitialized) {
3245 throw new Error("initializeWasm() must be awaited first!");
3247 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
3248 return nativeResponseValue;
3251 export function LDKAPIError_APIMisuseError_get_err(ptr: number): number {
3252 if(!isWasmInitialized) {
3253 throw new Error("initializeWasm() must be awaited first!");
3255 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
3256 return nativeResponseValue;
3259 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: number): number {
3260 if(!isWasmInitialized) {
3261 throw new Error("initializeWasm() must be awaited first!");
3263 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
3264 return nativeResponseValue;
3267 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: number): number {
3268 if(!isWasmInitialized) {
3269 throw new Error("initializeWasm() must be awaited first!");
3271 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
3272 return nativeResponseValue;
3275 export function LDKAPIError_RouteError_get_err(ptr: number): number {
3276 if(!isWasmInitialized) {
3277 throw new Error("initializeWasm() must be awaited first!");
3279 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
3280 return nativeResponseValue;
3283 export function LDKAPIError_ChannelUnavailable_get_err(ptr: number): number {
3284 if(!isWasmInitialized) {
3285 throw new Error("initializeWasm() must be awaited first!");
3287 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
3288 return nativeResponseValue;
3291 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: number): number {
3292 if(!isWasmInitialized) {
3293 throw new Error("initializeWasm() must be awaited first!");
3295 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
3296 return nativeResponseValue;
3298 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3300 export function CResult_NoneAPIErrorZ_get_ok(owner: number): void {
3301 if(!isWasmInitialized) {
3302 throw new Error("initializeWasm() must be awaited first!");
3304 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
3305 // debug statements here
3307 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3309 export function CResult_NoneAPIErrorZ_get_err(owner: number): number {
3310 if(!isWasmInitialized) {
3311 throw new Error("initializeWasm() must be awaited first!");
3313 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
3314 return nativeResponseValue;
3316 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3318 export function CResult__u832APIErrorZ_get_ok(owner: number): number {
3319 if(!isWasmInitialized) {
3320 throw new Error("initializeWasm() must be awaited first!");
3322 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
3323 return nativeResponseValue;
3325 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3327 export function CResult__u832APIErrorZ_get_err(owner: number): number {
3328 if(!isWasmInitialized) {
3329 throw new Error("initializeWasm() must be awaited first!");
3331 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
3332 return nativeResponseValue;
3335 export class LDKPaymentSendFailure {
3336 protected constructor() {}
3339 export function LDKPaymentSendFailure_ty_from_ptr(ptr: number): number {
3340 if(!isWasmInitialized) {
3341 throw new Error("initializeWasm() must be awaited first!");
3343 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
3344 return nativeResponseValue;
3347 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: number): number {
3348 if(!isWasmInitialized) {
3349 throw new Error("initializeWasm() must be awaited first!");
3351 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
3352 return nativeResponseValue;
3355 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: number): number {
3356 if(!isWasmInitialized) {
3357 throw new Error("initializeWasm() must be awaited first!");
3359 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
3360 return nativeResponseValue;
3363 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: number): number {
3364 if(!isWasmInitialized) {
3365 throw new Error("initializeWasm() must be awaited first!");
3367 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
3368 return nativeResponseValue;
3371 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: number): number {
3372 if(!isWasmInitialized) {
3373 throw new Error("initializeWasm() must be awaited first!");
3375 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
3376 return nativeResponseValue;
3379 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: number): number {
3380 if(!isWasmInitialized) {
3381 throw new Error("initializeWasm() must be awaited first!");
3383 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
3384 return nativeResponseValue;
3387 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: number): number {
3388 if(!isWasmInitialized) {
3389 throw new Error("initializeWasm() must be awaited first!");
3391 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
3392 return nativeResponseValue;
3394 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3396 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: number): number {
3397 if(!isWasmInitialized) {
3398 throw new Error("initializeWasm() must be awaited first!");
3400 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
3401 return nativeResponseValue;
3403 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3405 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: number): number {
3406 if(!isWasmInitialized) {
3407 throw new Error("initializeWasm() must be awaited first!");
3409 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
3410 return nativeResponseValue;
3412 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3414 export function CResult_NonePaymentSendFailureZ_get_ok(owner: number): void {
3415 if(!isWasmInitialized) {
3416 throw new Error("initializeWasm() must be awaited first!");
3418 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
3419 // debug statements here
3421 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3423 export function CResult_NonePaymentSendFailureZ_get_err(owner: number): number {
3424 if(!isWasmInitialized) {
3425 throw new Error("initializeWasm() must be awaited first!");
3427 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
3428 return nativeResponseValue;
3430 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3432 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: number): number {
3433 if(!isWasmInitialized) {
3434 throw new Error("initializeWasm() must be awaited first!");
3436 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
3437 return nativeResponseValue;
3439 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3441 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: number): number {
3442 if(!isWasmInitialized) {
3443 throw new Error("initializeWasm() must be awaited first!");
3445 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
3446 return nativeResponseValue;
3448 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3450 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: number): number {
3451 if(!isWasmInitialized) {
3452 throw new Error("initializeWasm() must be awaited first!");
3454 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
3455 return nativeResponseValue;
3457 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3459 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: number): number {
3460 if(!isWasmInitialized) {
3461 throw new Error("initializeWasm() must be awaited first!");
3463 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
3464 return nativeResponseValue;
3466 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3468 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: number): number {
3469 if(!isWasmInitialized) {
3470 throw new Error("initializeWasm() must be awaited first!");
3472 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
3473 return nativeResponseValue;
3475 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3477 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: number): number {
3478 if(!isWasmInitialized) {
3479 throw new Error("initializeWasm() must be awaited first!");
3481 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
3482 return nativeResponseValue;
3484 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3486 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: number): number {
3487 if(!isWasmInitialized) {
3488 throw new Error("initializeWasm() must be awaited first!");
3490 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
3491 return nativeResponseValue;
3493 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3495 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: number): void {
3496 if(!isWasmInitialized) {
3497 throw new Error("initializeWasm() must be awaited first!");
3499 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
3500 // debug statements here
3502 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3504 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: number): number {
3505 if(!isWasmInitialized) {
3506 throw new Error("initializeWasm() must be awaited first!");
3508 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
3509 return nativeResponseValue;
3511 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3513 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: number): number {
3514 if(!isWasmInitialized) {
3515 throw new Error("initializeWasm() must be awaited first!");
3517 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
3518 return nativeResponseValue;
3520 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3522 export function CResult_PaymentSecretNoneZ_get_ok(owner: number): number {
3523 if(!isWasmInitialized) {
3524 throw new Error("initializeWasm() must be awaited first!");
3526 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
3527 return nativeResponseValue;
3529 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3531 export function CResult_PaymentSecretNoneZ_get_err(owner: number): void {
3532 if(!isWasmInitialized) {
3533 throw new Error("initializeWasm() must be awaited first!");
3535 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
3536 // debug statements here
3538 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3540 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: number): number {
3541 if(!isWasmInitialized) {
3542 throw new Error("initializeWasm() must be awaited first!");
3544 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
3545 return nativeResponseValue;
3547 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3549 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: number): number {
3550 if(!isWasmInitialized) {
3551 throw new Error("initializeWasm() must be awaited first!");
3553 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
3554 return nativeResponseValue;
3556 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3558 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: number): number {
3559 if(!isWasmInitialized) {
3560 throw new Error("initializeWasm() must be awaited first!");
3562 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
3563 return nativeResponseValue;
3565 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3567 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: number): number {
3568 if(!isWasmInitialized) {
3569 throw new Error("initializeWasm() must be awaited first!");
3571 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
3572 return nativeResponseValue;
3574 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3576 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: number): number {
3577 if(!isWasmInitialized) {
3578 throw new Error("initializeWasm() must be awaited first!");
3580 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
3581 return nativeResponseValue;
3583 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3585 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: number): number {
3586 if(!isWasmInitialized) {
3587 throw new Error("initializeWasm() must be awaited first!");
3589 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
3590 return nativeResponseValue;
3592 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3594 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: number): number {
3595 if(!isWasmInitialized) {
3596 throw new Error("initializeWasm() must be awaited first!");
3598 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
3599 return nativeResponseValue;
3601 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3603 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: number): number {
3604 if(!isWasmInitialized) {
3605 throw new Error("initializeWasm() must be awaited first!");
3607 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
3608 return nativeResponseValue;
3610 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3612 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: number): number {
3613 if(!isWasmInitialized) {
3614 throw new Error("initializeWasm() must be awaited first!");
3616 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
3617 return nativeResponseValue;
3619 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3621 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: number): number {
3622 if(!isWasmInitialized) {
3623 throw new Error("initializeWasm() must be awaited first!");
3625 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
3626 return nativeResponseValue;
3628 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3630 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: number): number {
3631 if(!isWasmInitialized) {
3632 throw new Error("initializeWasm() must be awaited first!");
3634 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
3635 return nativeResponseValue;
3637 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3639 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: number): number {
3640 if(!isWasmInitialized) {
3641 throw new Error("initializeWasm() must be awaited first!");
3643 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
3644 return nativeResponseValue;
3647 export interface LDKWatch {
3648 watch_channel (funding_txo: number, monitor: number): number;
3649 update_channel (funding_txo: number, update: number): number;
3650 release_pending_monitor_events (): number;
3654 export function LDKWatch_new(impl: LDKWatch): number {
3655 if(!isWasmInitialized) {
3656 throw new Error("initializeWasm() must be awaited first!");
3658 var new_obj_idx = js_objs.length;
3659 for (var i = 0; i < js_objs.length; i++) {
3660 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3662 js_objs[i] = new WeakRef(impl);
3663 return wasm.TS_LDKWatch_new(i);
3665 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
3667 export function Watch_watch_channel(this_arg: number, funding_txo: number, monitor: number): number {
3668 if(!isWasmInitialized) {
3669 throw new Error("initializeWasm() must be awaited first!");
3671 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
3672 return nativeResponseValue;
3674 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
3676 export function Watch_update_channel(this_arg: number, funding_txo: number, update: number): number {
3677 if(!isWasmInitialized) {
3678 throw new Error("initializeWasm() must be awaited first!");
3680 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
3681 return nativeResponseValue;
3683 // LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
3685 export function Watch_release_pending_monitor_events(this_arg: number): number {
3686 if(!isWasmInitialized) {
3687 throw new Error("initializeWasm() must be awaited first!");
3689 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
3690 return nativeResponseValue;
3693 export interface LDKBroadcasterInterface {
3694 broadcast_transaction (tx: number): void;
3698 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): number {
3699 if(!isWasmInitialized) {
3700 throw new Error("initializeWasm() must be awaited first!");
3702 var new_obj_idx = js_objs.length;
3703 for (var i = 0; i < js_objs.length; i++) {
3704 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3706 js_objs[i] = new WeakRef(impl);
3707 return wasm.TS_LDKBroadcasterInterface_new(i);
3709 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
3711 export function BroadcasterInterface_broadcast_transaction(this_arg: number, tx: number): void {
3712 if(!isWasmInitialized) {
3713 throw new Error("initializeWasm() must be awaited first!");
3715 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
3716 // debug statements here
3719 export interface LDKKeysInterface {
3720 get_node_secret (recipient: Recipient): number;
3721 get_destination_script (): number;
3722 get_shutdown_scriptpubkey (): number;
3723 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): number;
3724 get_secure_random_bytes (): number;
3725 read_chan_signer (reader: number): number;
3726 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): number;
3727 get_inbound_payment_key_material (): number;
3731 export function LDKKeysInterface_new(impl: LDKKeysInterface): number {
3732 if(!isWasmInitialized) {
3733 throw new Error("initializeWasm() must be awaited first!");
3735 var new_obj_idx = js_objs.length;
3736 for (var i = 0; i < js_objs.length; i++) {
3737 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3739 js_objs[i] = new WeakRef(impl);
3740 return wasm.TS_LDKKeysInterface_new(i);
3742 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
3744 export function KeysInterface_get_node_secret(this_arg: number, recipient: Recipient): number {
3745 if(!isWasmInitialized) {
3746 throw new Error("initializeWasm() must be awaited first!");
3748 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
3749 return nativeResponseValue;
3751 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
3753 export function KeysInterface_get_destination_script(this_arg: number): number {
3754 if(!isWasmInitialized) {
3755 throw new Error("initializeWasm() must be awaited first!");
3757 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
3758 return nativeResponseValue;
3760 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
3762 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: number): number {
3763 if(!isWasmInitialized) {
3764 throw new Error("initializeWasm() must be awaited first!");
3766 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
3767 return nativeResponseValue;
3769 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
3771 export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: bigint): number {
3772 if(!isWasmInitialized) {
3773 throw new Error("initializeWasm() must be awaited first!");
3775 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
3776 return nativeResponseValue;
3778 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
3780 export function KeysInterface_get_secure_random_bytes(this_arg: number): number {
3781 if(!isWasmInitialized) {
3782 throw new Error("initializeWasm() must be awaited first!");
3784 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
3785 return nativeResponseValue;
3787 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
3789 export function KeysInterface_read_chan_signer(this_arg: number, reader: number): number {
3790 if(!isWasmInitialized) {
3791 throw new Error("initializeWasm() must be awaited first!");
3793 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
3794 return nativeResponseValue;
3796 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient
3798 export function KeysInterface_sign_invoice(this_arg: number, hrp_bytes: number, invoice_data: number, receipient: Recipient): number {
3799 if(!isWasmInitialized) {
3800 throw new Error("initializeWasm() must be awaited first!");
3802 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
3803 return nativeResponseValue;
3805 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
3807 export function KeysInterface_get_inbound_payment_key_material(this_arg: number): number {
3808 if(!isWasmInitialized) {
3809 throw new Error("initializeWasm() must be awaited first!");
3811 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
3812 return nativeResponseValue;
3815 export interface LDKFeeEstimator {
3816 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
3820 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
3821 if(!isWasmInitialized) {
3822 throw new Error("initializeWasm() must be awaited first!");
3824 var new_obj_idx = js_objs.length;
3825 for (var i = 0; i < js_objs.length; i++) {
3826 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3828 js_objs[i] = new WeakRef(impl);
3829 return wasm.TS_LDKFeeEstimator_new(i);
3831 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
3833 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: ConfirmationTarget): number {
3834 if(!isWasmInitialized) {
3835 throw new Error("initializeWasm() must be awaited first!");
3837 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
3838 return nativeResponseValue;
3840 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3842 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: number): number {
3843 if(!isWasmInitialized) {
3844 throw new Error("initializeWasm() must be awaited first!");
3846 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
3847 return nativeResponseValue;
3849 // struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3851 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: number): number {
3852 if(!isWasmInitialized) {
3853 throw new Error("initializeWasm() must be awaited first!");
3855 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
3856 return nativeResponseValue;
3858 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3860 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: number): number {
3861 if(!isWasmInitialized) {
3862 throw new Error("initializeWasm() must be awaited first!");
3864 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
3865 return nativeResponseValue;
3867 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3869 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: number): number {
3870 if(!isWasmInitialized) {
3871 throw new Error("initializeWasm() must be awaited first!");
3873 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
3874 return nativeResponseValue;
3876 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3878 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: number): number {
3879 if(!isWasmInitialized) {
3880 throw new Error("initializeWasm() must be awaited first!");
3882 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
3883 return nativeResponseValue;
3885 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3887 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: number): number {
3888 if(!isWasmInitialized) {
3889 throw new Error("initializeWasm() must be awaited first!");
3891 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
3892 return nativeResponseValue;
3894 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3896 export function CResult_OutPointDecodeErrorZ_get_ok(owner: number): number {
3897 if(!isWasmInitialized) {
3898 throw new Error("initializeWasm() must be awaited first!");
3900 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
3901 return nativeResponseValue;
3903 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3905 export function CResult_OutPointDecodeErrorZ_get_err(owner: number): number {
3906 if(!isWasmInitialized) {
3907 throw new Error("initializeWasm() must be awaited first!");
3909 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
3910 return nativeResponseValue;
3913 export interface LDKType {
3915 debug_str (): number;
3920 export function LDKType_new(impl: LDKType): 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_LDKType_new(i);
3931 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
3933 export function Type_type_id(this_arg: number): number {
3934 if(!isWasmInitialized) {
3935 throw new Error("initializeWasm() must be awaited first!");
3937 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
3938 return nativeResponseValue;
3940 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
3942 export function Type_debug_str(this_arg: number): number {
3943 if(!isWasmInitialized) {
3944 throw new Error("initializeWasm() must be awaited first!");
3946 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
3947 return nativeResponseValue;
3949 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
3951 export function Type_write(this_arg: number): number {
3952 if(!isWasmInitialized) {
3953 throw new Error("initializeWasm() must be awaited first!");
3955 const nativeResponseValue = wasm.TS_Type_write(this_arg);
3956 return nativeResponseValue;
3959 export class LDKCOption_TypeZ {
3960 protected constructor() {}
3963 export function LDKCOption_TypeZ_ty_from_ptr(ptr: number): number {
3964 if(!isWasmInitialized) {
3965 throw new Error("initializeWasm() must be awaited first!");
3967 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
3968 return nativeResponseValue;
3971 export function LDKCOption_TypeZ_Some_get_some(ptr: number): number {
3972 if(!isWasmInitialized) {
3973 throw new Error("initializeWasm() must be awaited first!");
3975 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
3976 return nativeResponseValue;
3978 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
3980 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: number): number {
3981 if(!isWasmInitialized) {
3982 throw new Error("initializeWasm() must be awaited first!");
3984 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
3985 return nativeResponseValue;
3987 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
3989 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: number): number {
3990 if(!isWasmInitialized) {
3991 throw new Error("initializeWasm() must be awaited first!");
3993 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
3994 return nativeResponseValue;
3997 export class LDKPaymentError {
3998 protected constructor() {}
4001 export function LDKPaymentError_ty_from_ptr(ptr: number): number {
4002 if(!isWasmInitialized) {
4003 throw new Error("initializeWasm() must be awaited first!");
4005 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
4006 return nativeResponseValue;
4009 export function LDKPaymentError_Invoice_get_invoice(ptr: number): number {
4010 if(!isWasmInitialized) {
4011 throw new Error("initializeWasm() must be awaited first!");
4013 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
4014 return nativeResponseValue;
4017 export function LDKPaymentError_Routing_get_routing(ptr: number): number {
4018 if(!isWasmInitialized) {
4019 throw new Error("initializeWasm() must be awaited first!");
4021 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
4022 return nativeResponseValue;
4025 export function LDKPaymentError_Sending_get_sending(ptr: number): number {
4026 if(!isWasmInitialized) {
4027 throw new Error("initializeWasm() must be awaited first!");
4029 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
4030 return nativeResponseValue;
4032 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4034 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: number): number {
4035 if(!isWasmInitialized) {
4036 throw new Error("initializeWasm() must be awaited first!");
4038 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
4039 return nativeResponseValue;
4041 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4043 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: number): number {
4044 if(!isWasmInitialized) {
4045 throw new Error("initializeWasm() must be awaited first!");
4047 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
4048 return nativeResponseValue;
4051 export class LDKParseError {
4052 protected constructor() {}
4055 export function LDKParseError_ty_from_ptr(ptr: number): number {
4056 if(!isWasmInitialized) {
4057 throw new Error("initializeWasm() must be awaited first!");
4059 const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
4060 return nativeResponseValue;
4063 export function LDKParseError_Bech32Error_get_bech32_error(ptr: number): number {
4064 if(!isWasmInitialized) {
4065 throw new Error("initializeWasm() must be awaited first!");
4067 const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
4068 return nativeResponseValue;
4071 export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: number): number {
4072 if(!isWasmInitialized) {
4073 throw new Error("initializeWasm() must be awaited first!");
4075 const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
4076 return nativeResponseValue;
4079 export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: number): Secp256k1Error {
4080 if(!isWasmInitialized) {
4081 throw new Error("initializeWasm() must be awaited first!");
4083 const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
4084 return nativeResponseValue;
4087 export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: number): number {
4088 if(!isWasmInitialized) {
4089 throw new Error("initializeWasm() must be awaited first!");
4091 const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
4092 return nativeResponseValue;
4095 export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: number): number {
4096 if(!isWasmInitialized) {
4097 throw new Error("initializeWasm() must be awaited first!");
4099 const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
4100 return nativeResponseValue;
4102 // enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4104 export function CResult_SiPrefixParseErrorZ_get_ok(owner: number): SiPrefix {
4105 if(!isWasmInitialized) {
4106 throw new Error("initializeWasm() must be awaited first!");
4108 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
4109 return nativeResponseValue;
4111 // struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4113 export function CResult_SiPrefixParseErrorZ_get_err(owner: number): number {
4114 if(!isWasmInitialized) {
4115 throw new Error("initializeWasm() must be awaited first!");
4117 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
4118 return nativeResponseValue;
4121 export class LDKParseOrSemanticError {
4122 protected constructor() {}
4125 export function LDKParseOrSemanticError_ty_from_ptr(ptr: number): number {
4126 if(!isWasmInitialized) {
4127 throw new Error("initializeWasm() must be awaited first!");
4129 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
4130 return nativeResponseValue;
4133 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: number): number {
4134 if(!isWasmInitialized) {
4135 throw new Error("initializeWasm() must be awaited first!");
4137 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
4138 return nativeResponseValue;
4141 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: number): SemanticError {
4142 if(!isWasmInitialized) {
4143 throw new Error("initializeWasm() must be awaited first!");
4145 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
4146 return nativeResponseValue;
4148 // struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4150 export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: number): number {
4151 if(!isWasmInitialized) {
4152 throw new Error("initializeWasm() must be awaited first!");
4154 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
4155 return nativeResponseValue;
4157 // struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4159 export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: number): number {
4160 if(!isWasmInitialized) {
4161 throw new Error("initializeWasm() must be awaited first!");
4163 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
4164 return nativeResponseValue;
4166 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4168 export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: number): number {
4169 if(!isWasmInitialized) {
4170 throw new Error("initializeWasm() must be awaited first!");
4172 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
4173 return nativeResponseValue;
4175 // struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4177 export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: number): number {
4178 if(!isWasmInitialized) {
4179 throw new Error("initializeWasm() must be awaited first!");
4181 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
4182 return nativeResponseValue;
4184 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4186 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: number): number {
4187 if(!isWasmInitialized) {
4188 throw new Error("initializeWasm() must be awaited first!");
4190 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
4191 return nativeResponseValue;
4193 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4195 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: number): number {
4196 if(!isWasmInitialized) {
4197 throw new Error("initializeWasm() must be awaited first!");
4199 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
4200 return nativeResponseValue;
4202 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4204 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: number): number {
4205 if(!isWasmInitialized) {
4206 throw new Error("initializeWasm() must be awaited first!");
4208 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
4209 return nativeResponseValue;
4211 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4213 export function CResult_PayeePubKeyErrorZ_get_ok(owner: number): number {
4214 if(!isWasmInitialized) {
4215 throw new Error("initializeWasm() must be awaited first!");
4217 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
4218 return nativeResponseValue;
4220 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4222 export function CResult_PayeePubKeyErrorZ_get_err(owner: number): Secp256k1Error {
4223 if(!isWasmInitialized) {
4224 throw new Error("initializeWasm() must be awaited first!");
4226 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
4227 return nativeResponseValue;
4229 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4231 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: number): number {
4232 if(!isWasmInitialized) {
4233 throw new Error("initializeWasm() must be awaited first!");
4235 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
4236 return nativeResponseValue;
4238 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4240 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: number): CreationError {
4241 if(!isWasmInitialized) {
4242 throw new Error("initializeWasm() must be awaited first!");
4244 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
4245 return nativeResponseValue;
4247 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4249 export function CResult_NoneSemanticErrorZ_get_ok(owner: number): void {
4250 if(!isWasmInitialized) {
4251 throw new Error("initializeWasm() must be awaited first!");
4253 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
4254 // debug statements here
4256 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4258 export function CResult_NoneSemanticErrorZ_get_err(owner: number): SemanticError {
4259 if(!isWasmInitialized) {
4260 throw new Error("initializeWasm() must be awaited first!");
4262 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
4263 return nativeResponseValue;
4265 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4267 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: number): number {
4268 if(!isWasmInitialized) {
4269 throw new Error("initializeWasm() must be awaited first!");
4271 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
4272 return nativeResponseValue;
4274 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4276 export function CResult_InvoiceSemanticErrorZ_get_err(owner: number): SemanticError {
4277 if(!isWasmInitialized) {
4278 throw new Error("initializeWasm() must be awaited first!");
4280 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
4281 return nativeResponseValue;
4283 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4285 export function CResult_DescriptionCreationErrorZ_get_ok(owner: number): number {
4286 if(!isWasmInitialized) {
4287 throw new Error("initializeWasm() must be awaited first!");
4289 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
4290 return nativeResponseValue;
4292 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4294 export function CResult_DescriptionCreationErrorZ_get_err(owner: number): CreationError {
4295 if(!isWasmInitialized) {
4296 throw new Error("initializeWasm() must be awaited first!");
4298 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
4299 return nativeResponseValue;
4301 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4303 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: number): number {
4304 if(!isWasmInitialized) {
4305 throw new Error("initializeWasm() must be awaited first!");
4307 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
4308 return nativeResponseValue;
4310 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4312 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: number): CreationError {
4313 if(!isWasmInitialized) {
4314 throw new Error("initializeWasm() must be awaited first!");
4316 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
4317 return nativeResponseValue;
4319 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4321 export function CResult_StringErrorZ_get_ok(owner: number): number {
4322 if(!isWasmInitialized) {
4323 throw new Error("initializeWasm() must be awaited first!");
4325 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
4326 return nativeResponseValue;
4328 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4330 export function CResult_StringErrorZ_get_err(owner: number): Secp256k1Error {
4331 if(!isWasmInitialized) {
4332 throw new Error("initializeWasm() must be awaited first!");
4334 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
4335 return nativeResponseValue;
4337 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4339 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: number): number {
4340 if(!isWasmInitialized) {
4341 throw new Error("initializeWasm() must be awaited first!");
4343 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
4344 return nativeResponseValue;
4346 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4348 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: number): number {
4349 if(!isWasmInitialized) {
4350 throw new Error("initializeWasm() must be awaited first!");
4352 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
4353 return nativeResponseValue;
4356 export class LDKCOption_MonitorEventZ {
4357 protected constructor() {}
4360 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: number): number {
4361 if(!isWasmInitialized) {
4362 throw new Error("initializeWasm() must be awaited first!");
4364 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
4365 return nativeResponseValue;
4368 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: number): number {
4369 if(!isWasmInitialized) {
4370 throw new Error("initializeWasm() must be awaited first!");
4372 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
4373 return nativeResponseValue;
4375 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4377 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: number): number {
4378 if(!isWasmInitialized) {
4379 throw new Error("initializeWasm() must be awaited first!");
4381 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
4382 return nativeResponseValue;
4384 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4386 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: number): number {
4387 if(!isWasmInitialized) {
4388 throw new Error("initializeWasm() must be awaited first!");
4390 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
4391 return nativeResponseValue;
4393 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4395 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: number): number {
4396 if(!isWasmInitialized) {
4397 throw new Error("initializeWasm() must be awaited first!");
4399 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
4400 return nativeResponseValue;
4402 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4404 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: number): number {
4405 if(!isWasmInitialized) {
4406 throw new Error("initializeWasm() must be awaited first!");
4408 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
4409 return nativeResponseValue;
4411 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4413 export function C2Tuple_OutPointScriptZ_get_a(owner: number): number {
4414 if(!isWasmInitialized) {
4415 throw new Error("initializeWasm() must be awaited first!");
4417 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
4418 return nativeResponseValue;
4420 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4422 export function C2Tuple_OutPointScriptZ_get_b(owner: number): number {
4423 if(!isWasmInitialized) {
4424 throw new Error("initializeWasm() must be awaited first!");
4426 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
4427 return nativeResponseValue;
4429 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4431 export function C2Tuple_u32ScriptZ_get_a(owner: number): number {
4432 if(!isWasmInitialized) {
4433 throw new Error("initializeWasm() must be awaited first!");
4435 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
4436 return nativeResponseValue;
4438 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4440 export function C2Tuple_u32ScriptZ_get_b(owner: number): number {
4441 if(!isWasmInitialized) {
4442 throw new Error("initializeWasm() must be awaited first!");
4444 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
4445 return nativeResponseValue;
4447 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4449 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: number): number {
4450 if(!isWasmInitialized) {
4451 throw new Error("initializeWasm() must be awaited first!");
4453 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
4454 return nativeResponseValue;
4456 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4458 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: number): number {
4459 if(!isWasmInitialized) {
4460 throw new Error("initializeWasm() must be awaited first!");
4462 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
4463 return nativeResponseValue;
4465 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4467 export function C2Tuple_u32TxOutZ_get_a(owner: number): number {
4468 if(!isWasmInitialized) {
4469 throw new Error("initializeWasm() must be awaited first!");
4471 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
4472 return nativeResponseValue;
4474 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4476 export function C2Tuple_u32TxOutZ_get_b(owner: number): number {
4477 if(!isWasmInitialized) {
4478 throw new Error("initializeWasm() must be awaited first!");
4480 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
4481 return nativeResponseValue;
4483 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4485 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: number): number {
4486 if(!isWasmInitialized) {
4487 throw new Error("initializeWasm() must be awaited first!");
4489 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
4490 return nativeResponseValue;
4492 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4494 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: number): number {
4495 if(!isWasmInitialized) {
4496 throw new Error("initializeWasm() must be awaited first!");
4498 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
4499 return nativeResponseValue;
4502 export class LDKBalance {
4503 protected constructor() {}
4506 export function LDKBalance_ty_from_ptr(ptr: number): number {
4507 if(!isWasmInitialized) {
4508 throw new Error("initializeWasm() must be awaited first!");
4510 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
4511 return nativeResponseValue;
4514 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: number): bigint {
4515 if(!isWasmInitialized) {
4516 throw new Error("initializeWasm() must be awaited first!");
4518 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
4519 return nativeResponseValue;
4522 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: number): bigint {
4523 if(!isWasmInitialized) {
4524 throw new Error("initializeWasm() must be awaited first!");
4526 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
4527 return nativeResponseValue;
4530 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: number): number {
4531 if(!isWasmInitialized) {
4532 throw new Error("initializeWasm() must be awaited first!");
4534 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
4535 return nativeResponseValue;
4538 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: number): bigint {
4539 if(!isWasmInitialized) {
4540 throw new Error("initializeWasm() must be awaited first!");
4542 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
4543 return nativeResponseValue;
4546 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: number): number {
4547 if(!isWasmInitialized) {
4548 throw new Error("initializeWasm() must be awaited first!");
4550 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
4551 return nativeResponseValue;
4554 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr: number): bigint {
4555 if(!isWasmInitialized) {
4556 throw new Error("initializeWasm() must be awaited first!");
4558 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr);
4559 return nativeResponseValue;
4562 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr: number): number {
4563 if(!isWasmInitialized) {
4564 throw new Error("initializeWasm() must be awaited first!");
4566 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr);
4567 return nativeResponseValue;
4569 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4571 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: number): number {
4572 if(!isWasmInitialized) {
4573 throw new Error("initializeWasm() must be awaited first!");
4575 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
4576 return nativeResponseValue;
4578 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4580 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: number): number {
4581 if(!isWasmInitialized) {
4582 throw new Error("initializeWasm() must be awaited first!");
4584 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
4585 return nativeResponseValue;
4587 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4589 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: number): number {
4590 if(!isWasmInitialized) {
4591 throw new Error("initializeWasm() must be awaited first!");
4593 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
4594 return nativeResponseValue;
4596 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4598 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: number): number {
4599 if(!isWasmInitialized) {
4600 throw new Error("initializeWasm() must be awaited first!");
4602 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
4603 return nativeResponseValue;
4605 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4607 export function C2Tuple_PublicKeyTypeZ_get_a(owner: number): number {
4608 if(!isWasmInitialized) {
4609 throw new Error("initializeWasm() must be awaited first!");
4611 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
4612 return nativeResponseValue;
4614 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4616 export function C2Tuple_PublicKeyTypeZ_get_b(owner: number): number {
4617 if(!isWasmInitialized) {
4618 throw new Error("initializeWasm() must be awaited first!");
4620 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
4621 return nativeResponseValue;
4624 export class LDKCOption_NetAddressZ {
4625 protected constructor() {}
4628 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: number): number {
4629 if(!isWasmInitialized) {
4630 throw new Error("initializeWasm() must be awaited first!");
4632 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
4633 return nativeResponseValue;
4636 export function LDKCOption_NetAddressZ_Some_get_some(ptr: number): number {
4637 if(!isWasmInitialized) {
4638 throw new Error("initializeWasm() must be awaited first!");
4640 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
4641 return nativeResponseValue;
4643 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4645 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: number): number {
4646 if(!isWasmInitialized) {
4647 throw new Error("initializeWasm() must be awaited first!");
4649 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
4650 return nativeResponseValue;
4652 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4654 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: number): number {
4655 if(!isWasmInitialized) {
4656 throw new Error("initializeWasm() must be awaited first!");
4658 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
4659 return nativeResponseValue;
4661 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4663 export function CResult_NonePeerHandleErrorZ_get_ok(owner: number): void {
4664 if(!isWasmInitialized) {
4665 throw new Error("initializeWasm() must be awaited first!");
4667 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
4668 // debug statements here
4670 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4672 export function CResult_NonePeerHandleErrorZ_get_err(owner: number): number {
4673 if(!isWasmInitialized) {
4674 throw new Error("initializeWasm() must be awaited first!");
4676 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
4677 return nativeResponseValue;
4679 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4681 export function CResult_boolPeerHandleErrorZ_get_ok(owner: number): boolean {
4682 if(!isWasmInitialized) {
4683 throw new Error("initializeWasm() must be awaited first!");
4685 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
4686 return nativeResponseValue;
4688 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4690 export function CResult_boolPeerHandleErrorZ_get_err(owner: number): number {
4691 if(!isWasmInitialized) {
4692 throw new Error("initializeWasm() must be awaited first!");
4694 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
4695 return nativeResponseValue;
4697 // void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4699 export function CResult_NoneErrorZ_get_ok(owner: number): void {
4700 if(!isWasmInitialized) {
4701 throw new Error("initializeWasm() must be awaited first!");
4703 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_ok(owner);
4704 // debug statements here
4706 // enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4708 export function CResult_NoneErrorZ_get_err(owner: number): IOError {
4709 if(!isWasmInitialized) {
4710 throw new Error("initializeWasm() must be awaited first!");
4712 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_err(owner);
4713 return nativeResponseValue;
4715 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4717 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: number): number {
4718 if(!isWasmInitialized) {
4719 throw new Error("initializeWasm() must be awaited first!");
4721 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
4722 return nativeResponseValue;
4724 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4726 export function CResult_NetAddressDecodeErrorZ_get_err(owner: number): number {
4727 if(!isWasmInitialized) {
4728 throw new Error("initializeWasm() must be awaited first!");
4730 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
4731 return nativeResponseValue;
4733 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4735 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: number): number {
4736 if(!isWasmInitialized) {
4737 throw new Error("initializeWasm() must be awaited first!");
4739 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
4740 return nativeResponseValue;
4742 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4744 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: number): number {
4745 if(!isWasmInitialized) {
4746 throw new Error("initializeWasm() must be awaited first!");
4748 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
4749 return nativeResponseValue;
4751 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4753 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: number): number {
4754 if(!isWasmInitialized) {
4755 throw new Error("initializeWasm() must be awaited first!");
4757 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
4758 return nativeResponseValue;
4760 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4762 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: number): number {
4763 if(!isWasmInitialized) {
4764 throw new Error("initializeWasm() must be awaited first!");
4766 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
4767 return nativeResponseValue;
4769 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4771 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: number): number {
4772 if(!isWasmInitialized) {
4773 throw new Error("initializeWasm() must be awaited first!");
4775 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
4776 return nativeResponseValue;
4778 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4780 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: number): number {
4781 if(!isWasmInitialized) {
4782 throw new Error("initializeWasm() must be awaited first!");
4784 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
4785 return nativeResponseValue;
4787 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4789 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: number): number {
4790 if(!isWasmInitialized) {
4791 throw new Error("initializeWasm() must be awaited first!");
4793 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
4794 return nativeResponseValue;
4796 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4798 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: number): number {
4799 if(!isWasmInitialized) {
4800 throw new Error("initializeWasm() must be awaited first!");
4802 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
4803 return nativeResponseValue;
4805 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4807 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: number): number {
4808 if(!isWasmInitialized) {
4809 throw new Error("initializeWasm() must be awaited first!");
4811 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
4812 return nativeResponseValue;
4814 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4816 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: number): number {
4817 if(!isWasmInitialized) {
4818 throw new Error("initializeWasm() must be awaited first!");
4820 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
4821 return nativeResponseValue;
4823 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4825 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: number): number {
4826 if(!isWasmInitialized) {
4827 throw new Error("initializeWasm() must be awaited first!");
4829 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
4830 return nativeResponseValue;
4832 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4834 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: number): number {
4835 if(!isWasmInitialized) {
4836 throw new Error("initializeWasm() must be awaited first!");
4838 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
4839 return nativeResponseValue;
4841 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4843 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: number): number {
4844 if(!isWasmInitialized) {
4845 throw new Error("initializeWasm() must be awaited first!");
4847 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
4848 return nativeResponseValue;
4850 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4852 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: number): number {
4853 if(!isWasmInitialized) {
4854 throw new Error("initializeWasm() must be awaited first!");
4856 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
4857 return nativeResponseValue;
4859 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4861 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: number): number {
4862 if(!isWasmInitialized) {
4863 throw new Error("initializeWasm() must be awaited first!");
4865 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
4866 return nativeResponseValue;
4868 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4870 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: number): number {
4871 if(!isWasmInitialized) {
4872 throw new Error("initializeWasm() must be awaited first!");
4874 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
4875 return nativeResponseValue;
4877 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
4879 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: number): number {
4880 if(!isWasmInitialized) {
4881 throw new Error("initializeWasm() must be awaited first!");
4883 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
4884 return nativeResponseValue;
4886 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
4888 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: number): number {
4889 if(!isWasmInitialized) {
4890 throw new Error("initializeWasm() must be awaited first!");
4892 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
4893 return nativeResponseValue;
4895 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4897 export function CResult_InitDecodeErrorZ_get_ok(owner: number): number {
4898 if(!isWasmInitialized) {
4899 throw new Error("initializeWasm() must be awaited first!");
4901 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
4902 return nativeResponseValue;
4904 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4906 export function CResult_InitDecodeErrorZ_get_err(owner: number): number {
4907 if(!isWasmInitialized) {
4908 throw new Error("initializeWasm() must be awaited first!");
4910 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
4911 return nativeResponseValue;
4913 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
4915 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: number): number {
4916 if(!isWasmInitialized) {
4917 throw new Error("initializeWasm() must be awaited first!");
4919 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
4920 return nativeResponseValue;
4922 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
4924 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: number): number {
4925 if(!isWasmInitialized) {
4926 throw new Error("initializeWasm() must be awaited first!");
4928 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
4929 return nativeResponseValue;
4931 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
4933 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: number): number {
4934 if(!isWasmInitialized) {
4935 throw new Error("initializeWasm() must be awaited first!");
4937 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
4938 return nativeResponseValue;
4940 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
4942 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: number): number {
4943 if(!isWasmInitialized) {
4944 throw new Error("initializeWasm() must be awaited first!");
4946 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
4947 return nativeResponseValue;
4949 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
4951 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: number): number {
4952 if(!isWasmInitialized) {
4953 throw new Error("initializeWasm() must be awaited first!");
4955 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
4956 return nativeResponseValue;
4958 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
4960 export function CResult_ShutdownDecodeErrorZ_get_err(owner: number): number {
4961 if(!isWasmInitialized) {
4962 throw new Error("initializeWasm() must be awaited first!");
4964 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
4965 return nativeResponseValue;
4967 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
4969 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: number): number {
4970 if(!isWasmInitialized) {
4971 throw new Error("initializeWasm() must be awaited first!");
4973 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
4974 return nativeResponseValue;
4976 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
4978 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: number): number {
4979 if(!isWasmInitialized) {
4980 throw new Error("initializeWasm() must be awaited first!");
4982 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
4983 return nativeResponseValue;
4985 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
4987 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: number): number {
4988 if(!isWasmInitialized) {
4989 throw new Error("initializeWasm() must be awaited first!");
4991 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
4992 return nativeResponseValue;
4994 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
4996 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: number): number {
4997 if(!isWasmInitialized) {
4998 throw new Error("initializeWasm() must be awaited first!");
5000 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
5001 return nativeResponseValue;
5003 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5005 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: number): number {
5006 if(!isWasmInitialized) {
5007 throw new Error("initializeWasm() must be awaited first!");
5009 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
5010 return nativeResponseValue;
5012 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5014 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: number): number {
5015 if(!isWasmInitialized) {
5016 throw new Error("initializeWasm() must be awaited first!");
5018 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
5019 return nativeResponseValue;
5021 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5023 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: number): number {
5024 if(!isWasmInitialized) {
5025 throw new Error("initializeWasm() must be awaited first!");
5027 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
5028 return nativeResponseValue;
5030 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5032 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: number): number {
5033 if(!isWasmInitialized) {
5034 throw new Error("initializeWasm() must be awaited first!");
5036 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
5037 return nativeResponseValue;
5039 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5041 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: number): number {
5042 if(!isWasmInitialized) {
5043 throw new Error("initializeWasm() must be awaited first!");
5045 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
5046 return nativeResponseValue;
5048 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5050 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: number): number {
5051 if(!isWasmInitialized) {
5052 throw new Error("initializeWasm() must be awaited first!");
5054 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
5055 return nativeResponseValue;
5057 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5059 export function CResult_PingDecodeErrorZ_get_ok(owner: number): number {
5060 if(!isWasmInitialized) {
5061 throw new Error("initializeWasm() must be awaited first!");
5063 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
5064 return nativeResponseValue;
5066 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5068 export function CResult_PingDecodeErrorZ_get_err(owner: number): number {
5069 if(!isWasmInitialized) {
5070 throw new Error("initializeWasm() must be awaited first!");
5072 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
5073 return nativeResponseValue;
5075 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5077 export function CResult_PongDecodeErrorZ_get_ok(owner: number): number {
5078 if(!isWasmInitialized) {
5079 throw new Error("initializeWasm() must be awaited first!");
5081 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
5082 return nativeResponseValue;
5084 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5086 export function CResult_PongDecodeErrorZ_get_err(owner: number): number {
5087 if(!isWasmInitialized) {
5088 throw new Error("initializeWasm() must be awaited first!");
5090 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
5091 return nativeResponseValue;
5093 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5095 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5096 if(!isWasmInitialized) {
5097 throw new Error("initializeWasm() must be awaited first!");
5099 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
5100 return nativeResponseValue;
5102 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5104 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5105 if(!isWasmInitialized) {
5106 throw new Error("initializeWasm() must be awaited first!");
5108 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
5109 return nativeResponseValue;
5111 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5113 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5114 if(!isWasmInitialized) {
5115 throw new Error("initializeWasm() must be awaited first!");
5117 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
5118 return nativeResponseValue;
5120 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5122 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5123 if(!isWasmInitialized) {
5124 throw new Error("initializeWasm() must be awaited first!");
5126 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
5127 return nativeResponseValue;
5129 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5131 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5132 if(!isWasmInitialized) {
5133 throw new Error("initializeWasm() must be awaited first!");
5135 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
5136 return nativeResponseValue;
5138 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5140 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5141 if(!isWasmInitialized) {
5142 throw new Error("initializeWasm() must be awaited first!");
5144 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
5145 return nativeResponseValue;
5147 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5149 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5150 if(!isWasmInitialized) {
5151 throw new Error("initializeWasm() must be awaited first!");
5153 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
5154 return nativeResponseValue;
5156 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5158 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5159 if(!isWasmInitialized) {
5160 throw new Error("initializeWasm() must be awaited first!");
5162 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
5163 return nativeResponseValue;
5165 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5167 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: number): number {
5168 if(!isWasmInitialized) {
5169 throw new Error("initializeWasm() must be awaited first!");
5171 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
5172 return nativeResponseValue;
5174 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5176 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: number): number {
5177 if(!isWasmInitialized) {
5178 throw new Error("initializeWasm() must be awaited first!");
5180 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
5181 return nativeResponseValue;
5183 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5185 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: number): number {
5186 if(!isWasmInitialized) {
5187 throw new Error("initializeWasm() must be awaited first!");
5189 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
5190 return nativeResponseValue;
5192 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5194 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: number): number {
5195 if(!isWasmInitialized) {
5196 throw new Error("initializeWasm() must be awaited first!");
5198 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
5199 return nativeResponseValue;
5201 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5203 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5204 if(!isWasmInitialized) {
5205 throw new Error("initializeWasm() must be awaited first!");
5207 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
5208 return nativeResponseValue;
5210 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5212 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5213 if(!isWasmInitialized) {
5214 throw new Error("initializeWasm() must be awaited first!");
5216 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
5217 return nativeResponseValue;
5219 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5221 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5222 if(!isWasmInitialized) {
5223 throw new Error("initializeWasm() must be awaited first!");
5225 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
5226 return nativeResponseValue;
5228 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5230 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5231 if(!isWasmInitialized) {
5232 throw new Error("initializeWasm() must be awaited first!");
5234 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
5235 return nativeResponseValue;
5237 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5239 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: number): number {
5240 if(!isWasmInitialized) {
5241 throw new Error("initializeWasm() must be awaited first!");
5243 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
5244 return nativeResponseValue;
5246 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5248 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: number): number {
5249 if(!isWasmInitialized) {
5250 throw new Error("initializeWasm() must be awaited first!");
5252 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
5253 return nativeResponseValue;
5255 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5257 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: number): number {
5258 if(!isWasmInitialized) {
5259 throw new Error("initializeWasm() must be awaited first!");
5261 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
5262 return nativeResponseValue;
5264 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5266 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: number): number {
5267 if(!isWasmInitialized) {
5268 throw new Error("initializeWasm() must be awaited first!");
5270 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
5271 return nativeResponseValue;
5273 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5275 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5276 if(!isWasmInitialized) {
5277 throw new Error("initializeWasm() must be awaited first!");
5279 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
5280 return nativeResponseValue;
5282 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5284 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: number): number {
5285 if(!isWasmInitialized) {
5286 throw new Error("initializeWasm() must be awaited first!");
5288 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
5289 return nativeResponseValue;
5291 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5293 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5294 if(!isWasmInitialized) {
5295 throw new Error("initializeWasm() must be awaited first!");
5297 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
5298 return nativeResponseValue;
5300 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5302 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: number): number {
5303 if(!isWasmInitialized) {
5304 throw new Error("initializeWasm() must be awaited first!");
5306 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
5307 return nativeResponseValue;
5309 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5311 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: number): number {
5312 if(!isWasmInitialized) {
5313 throw new Error("initializeWasm() must be awaited first!");
5315 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
5316 return nativeResponseValue;
5318 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5320 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: number): number {
5321 if(!isWasmInitialized) {
5322 throw new Error("initializeWasm() must be awaited first!");
5324 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
5325 return nativeResponseValue;
5328 export class LDKSignOrCreationError {
5329 protected constructor() {}
5332 export function LDKSignOrCreationError_ty_from_ptr(ptr: number): number {
5333 if(!isWasmInitialized) {
5334 throw new Error("initializeWasm() must be awaited first!");
5336 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
5337 return nativeResponseValue;
5340 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: number): CreationError {
5341 if(!isWasmInitialized) {
5342 throw new Error("initializeWasm() must be awaited first!");
5344 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
5345 return nativeResponseValue;
5347 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5349 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: number): number {
5350 if(!isWasmInitialized) {
5351 throw new Error("initializeWasm() must be awaited first!");
5353 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
5354 return nativeResponseValue;
5356 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5358 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: number): number {
5359 if(!isWasmInitialized) {
5360 throw new Error("initializeWasm() must be awaited first!");
5362 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
5363 return nativeResponseValue;
5366 export interface LDKFilter {
5367 register_tx (txid: number, script_pubkey: number): void;
5368 register_output (output: number): number;
5372 export function LDKFilter_new(impl: LDKFilter): number {
5373 if(!isWasmInitialized) {
5374 throw new Error("initializeWasm() must be awaited first!");
5376 var new_obj_idx = js_objs.length;
5377 for (var i = 0; i < js_objs.length; i++) {
5378 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5380 js_objs[i] = new WeakRef(impl);
5381 return wasm.TS_LDKFilter_new(i);
5383 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
5385 export function Filter_register_tx(this_arg: number, txid: number, script_pubkey: number): void {
5386 if(!isWasmInitialized) {
5387 throw new Error("initializeWasm() must be awaited first!");
5389 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
5390 // debug statements here
5392 // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
5394 export function Filter_register_output(this_arg: number, output: number): number {
5395 if(!isWasmInitialized) {
5396 throw new Error("initializeWasm() must be awaited first!");
5398 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
5399 return nativeResponseValue;
5402 export class LDKCOption_FilterZ {
5403 protected constructor() {}
5406 export function LDKCOption_FilterZ_ty_from_ptr(ptr: number): number {
5407 if(!isWasmInitialized) {
5408 throw new Error("initializeWasm() must be awaited first!");
5410 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
5411 return nativeResponseValue;
5414 export function LDKCOption_FilterZ_Some_get_some(ptr: number): number {
5415 if(!isWasmInitialized) {
5416 throw new Error("initializeWasm() must be awaited first!");
5418 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
5419 return nativeResponseValue;
5421 // struct LDKLockedChannelMonitor *CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5423 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: number): number {
5424 if(!isWasmInitialized) {
5425 throw new Error("initializeWasm() must be awaited first!");
5427 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
5428 return nativeResponseValue;
5430 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5432 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: number): void {
5433 if(!isWasmInitialized) {
5434 throw new Error("initializeWasm() must be awaited first!");
5436 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
5437 // debug statements here
5440 export interface LDKMessageSendEventsProvider {
5441 get_and_clear_pending_msg_events (): number;
5445 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): number {
5446 if(!isWasmInitialized) {
5447 throw new Error("initializeWasm() must be awaited first!");
5449 var new_obj_idx = js_objs.length;
5450 for (var i = 0; i < js_objs.length; i++) {
5451 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5453 js_objs[i] = new WeakRef(impl);
5454 return wasm.TS_LDKMessageSendEventsProvider_new(i);
5456 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
5458 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: number): number {
5459 if(!isWasmInitialized) {
5460 throw new Error("initializeWasm() must be awaited first!");
5462 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
5463 return nativeResponseValue;
5466 export interface LDKEventHandler {
5467 handle_event (event: number): void;
5471 export function LDKEventHandler_new(impl: LDKEventHandler): number {
5472 if(!isWasmInitialized) {
5473 throw new Error("initializeWasm() must be awaited first!");
5475 var new_obj_idx = js_objs.length;
5476 for (var i = 0; i < js_objs.length; i++) {
5477 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5479 js_objs[i] = new WeakRef(impl);
5480 return wasm.TS_LDKEventHandler_new(i);
5482 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
5484 export function EventHandler_handle_event(this_arg: number, event: number): void {
5485 if(!isWasmInitialized) {
5486 throw new Error("initializeWasm() must be awaited first!");
5488 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
5489 // debug statements here
5492 export interface LDKEventsProvider {
5493 process_pending_events (handler: number): void;
5497 export function LDKEventsProvider_new(impl: LDKEventsProvider): number {
5498 if(!isWasmInitialized) {
5499 throw new Error("initializeWasm() must be awaited first!");
5501 var new_obj_idx = js_objs.length;
5502 for (var i = 0; i < js_objs.length; i++) {
5503 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5505 js_objs[i] = new WeakRef(impl);
5506 return wasm.TS_LDKEventsProvider_new(i);
5508 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
5510 export function EventsProvider_process_pending_events(this_arg: number, handler: number): void {
5511 if(!isWasmInitialized) {
5512 throw new Error("initializeWasm() must be awaited first!");
5514 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
5515 // debug statements here
5518 export interface LDKScore {
5519 channel_penalty_msat (short_channel_id: bigint, source: number, target: number, usage: number): bigint;
5520 payment_path_failed (path: number, short_channel_id: bigint): void;
5521 payment_path_successful (path: number): void;
5526 export function LDKScore_new(impl: LDKScore): number {
5527 if(!isWasmInitialized) {
5528 throw new Error("initializeWasm() must be awaited first!");
5530 var new_obj_idx = js_objs.length;
5531 for (var i = 0; i < js_objs.length; i++) {
5532 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5534 js_objs[i] = new WeakRef(impl);
5535 return wasm.TS_LDKScore_new(i);
5537 // 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
5539 export function Score_channel_penalty_msat(this_arg: number, short_channel_id: bigint, source: number, target: number, usage: number): bigint {
5540 if(!isWasmInitialized) {
5541 throw new Error("initializeWasm() must be awaited first!");
5543 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage);
5544 return nativeResponseValue;
5546 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5548 export function Score_payment_path_failed(this_arg: number, path: number, short_channel_id: bigint): void {
5549 if(!isWasmInitialized) {
5550 throw new Error("initializeWasm() must be awaited first!");
5552 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
5553 // debug statements here
5555 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5557 export function Score_payment_path_successful(this_arg: number, path: number): void {
5558 if(!isWasmInitialized) {
5559 throw new Error("initializeWasm() must be awaited first!");
5561 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
5562 // debug statements here
5564 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
5566 export function Score_write(this_arg: number): number {
5567 if(!isWasmInitialized) {
5568 throw new Error("initializeWasm() must be awaited first!");
5570 const nativeResponseValue = wasm.TS_Score_write(this_arg);
5571 return nativeResponseValue;
5574 export interface LDKPersister {
5575 persist_manager (channel_manager: number): number;
5576 persist_graph (network_graph: number): number;
5577 persist_scorer (scorer: number): number;
5581 export function LDKPersister_new(impl: LDKPersister): number {
5582 if(!isWasmInitialized) {
5583 throw new Error("initializeWasm() must be awaited first!");
5585 var new_obj_idx = js_objs.length;
5586 for (var i = 0; i < js_objs.length; i++) {
5587 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5589 js_objs[i] = new WeakRef(impl);
5590 return wasm.TS_LDKPersister_new(i);
5592 // LDKCResult_NoneErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
5594 export function Persister_persist_manager(this_arg: number, channel_manager: number): number {
5595 if(!isWasmInitialized) {
5596 throw new Error("initializeWasm() must be awaited first!");
5598 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
5599 return nativeResponseValue;
5601 // LDKCResult_NoneErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
5603 export function Persister_persist_graph(this_arg: number, network_graph: number): number {
5604 if(!isWasmInitialized) {
5605 throw new Error("initializeWasm() must be awaited first!");
5607 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
5608 return nativeResponseValue;
5610 // LDKCResult_NoneErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKMultiThreadedLockableScore *NONNULL_PTR scorer
5612 export function Persister_persist_scorer(this_arg: number, scorer: number): number {
5613 if(!isWasmInitialized) {
5614 throw new Error("initializeWasm() must be awaited first!");
5616 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
5617 return nativeResponseValue;
5620 export interface LDKListen {
5621 filtered_block_connected (header: number, txdata: number, height: number): void;
5622 block_connected (block: number, height: number): void;
5623 block_disconnected (header: number, height: number): void;
5627 export function LDKListen_new(impl: LDKListen): number {
5628 if(!isWasmInitialized) {
5629 throw new Error("initializeWasm() must be awaited first!");
5631 var new_obj_idx = js_objs.length;
5632 for (var i = 0; i < js_objs.length; i++) {
5633 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5635 js_objs[i] = new WeakRef(impl);
5636 return wasm.TS_LDKListen_new(i);
5638 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5640 export function Listen_filtered_block_connected(this_arg: number, header: number, txdata: number, height: number): void {
5641 if(!isWasmInitialized) {
5642 throw new Error("initializeWasm() must be awaited first!");
5644 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
5645 // debug statements here
5647 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
5649 export function Listen_block_connected(this_arg: number, block: number, height: number): void {
5650 if(!isWasmInitialized) {
5651 throw new Error("initializeWasm() must be awaited first!");
5653 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
5654 // debug statements here
5656 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5658 export function Listen_block_disconnected(this_arg: number, header: number, height: number): void {
5659 if(!isWasmInitialized) {
5660 throw new Error("initializeWasm() must be awaited first!");
5662 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
5663 // debug statements here
5666 export interface LDKConfirm {
5667 transactions_confirmed (header: number, txdata: number, height: number): void;
5668 transaction_unconfirmed (txid: number): void;
5669 best_block_updated (header: number, height: number): void;
5670 get_relevant_txids (): number;
5674 export function LDKConfirm_new(impl: LDKConfirm): number {
5675 if(!isWasmInitialized) {
5676 throw new Error("initializeWasm() must be awaited first!");
5678 var new_obj_idx = js_objs.length;
5679 for (var i = 0; i < js_objs.length; i++) {
5680 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5682 js_objs[i] = new WeakRef(impl);
5683 return wasm.TS_LDKConfirm_new(i);
5685 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5687 export function Confirm_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number): void {
5688 if(!isWasmInitialized) {
5689 throw new Error("initializeWasm() must be awaited first!");
5691 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
5692 // debug statements here
5694 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
5696 export function Confirm_transaction_unconfirmed(this_arg: number, txid: number): void {
5697 if(!isWasmInitialized) {
5698 throw new Error("initializeWasm() must be awaited first!");
5700 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
5701 // debug statements here
5703 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5705 export function Confirm_best_block_updated(this_arg: number, header: number, height: number): void {
5706 if(!isWasmInitialized) {
5707 throw new Error("initializeWasm() must be awaited first!");
5709 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
5710 // debug statements here
5712 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
5714 export function Confirm_get_relevant_txids(this_arg: number): number {
5715 if(!isWasmInitialized) {
5716 throw new Error("initializeWasm() must be awaited first!");
5718 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
5719 return nativeResponseValue;
5722 export interface LDKPersist {
5723 persist_new_channel (channel_id: number, data: number, update_id: number): number;
5724 update_persisted_channel (channel_id: number, update: number, data: number, update_id: number): number;
5728 export function LDKPersist_new(impl: LDKPersist): number {
5729 if(!isWasmInitialized) {
5730 throw new Error("initializeWasm() must be awaited first!");
5732 var new_obj_idx = js_objs.length;
5733 for (var i = 0; i < js_objs.length; i++) {
5734 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5736 js_objs[i] = new WeakRef(impl);
5737 return wasm.TS_LDKPersist_new(i);
5739 // 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
5741 export function Persist_persist_new_channel(this_arg: number, channel_id: number, data: number, update_id: number): number {
5742 if(!isWasmInitialized) {
5743 throw new Error("initializeWasm() must be awaited first!");
5745 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
5746 return nativeResponseValue;
5748 // 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
5750 export function Persist_update_persisted_channel(this_arg: number, channel_id: number, update: number, data: number, update_id: number): number {
5751 if(!isWasmInitialized) {
5752 throw new Error("initializeWasm() must be awaited first!");
5754 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
5755 return nativeResponseValue;
5758 export interface LDKChannelMessageHandler {
5759 handle_open_channel (their_node_id: number, their_features: number, msg: number): void;
5760 handle_accept_channel (their_node_id: number, their_features: number, msg: number): void;
5761 handle_funding_created (their_node_id: number, msg: number): void;
5762 handle_funding_signed (their_node_id: number, msg: number): void;
5763 handle_channel_ready (their_node_id: number, msg: number): void;
5764 handle_shutdown (their_node_id: number, their_features: number, msg: number): void;
5765 handle_closing_signed (their_node_id: number, msg: number): void;
5766 handle_update_add_htlc (their_node_id: number, msg: number): void;
5767 handle_update_fulfill_htlc (their_node_id: number, msg: number): void;
5768 handle_update_fail_htlc (their_node_id: number, msg: number): void;
5769 handle_update_fail_malformed_htlc (their_node_id: number, msg: number): void;
5770 handle_commitment_signed (their_node_id: number, msg: number): void;
5771 handle_revoke_and_ack (their_node_id: number, msg: number): void;
5772 handle_update_fee (their_node_id: number, msg: number): void;
5773 handle_announcement_signatures (their_node_id: number, msg: number): void;
5774 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
5775 peer_connected (their_node_id: number, msg: number): void;
5776 handle_channel_reestablish (their_node_id: number, msg: number): void;
5777 handle_channel_update (their_node_id: number, msg: number): void;
5778 handle_error (their_node_id: number, msg: number): void;
5782 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
5783 if(!isWasmInitialized) {
5784 throw new Error("initializeWasm() must be awaited first!");
5786 var new_obj_idx = js_objs.length;
5787 for (var i = 0; i < js_objs.length; i++) {
5788 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5790 js_objs[i] = new WeakRef(impl);
5791 return wasm.TS_LDKChannelMessageHandler_new(i);
5793 // 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
5795 export function ChannelMessageHandler_handle_open_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5796 if(!isWasmInitialized) {
5797 throw new Error("initializeWasm() must be awaited first!");
5799 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
5800 // debug statements here
5802 // 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
5804 export function ChannelMessageHandler_handle_accept_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5805 if(!isWasmInitialized) {
5806 throw new Error("initializeWasm() must be awaited first!");
5808 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
5809 // debug statements here
5811 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
5813 export function ChannelMessageHandler_handle_funding_created(this_arg: number, their_node_id: number, msg: number): void {
5814 if(!isWasmInitialized) {
5815 throw new Error("initializeWasm() must be awaited first!");
5817 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
5818 // debug statements here
5820 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
5822 export function ChannelMessageHandler_handle_funding_signed(this_arg: number, their_node_id: number, msg: number): void {
5823 if(!isWasmInitialized) {
5824 throw new Error("initializeWasm() must be awaited first!");
5826 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
5827 // debug statements here
5829 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
5831 export function ChannelMessageHandler_handle_channel_ready(this_arg: number, their_node_id: number, msg: number): void {
5832 if(!isWasmInitialized) {
5833 throw new Error("initializeWasm() must be awaited first!");
5835 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
5836 // debug statements here
5838 // 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
5840 export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5841 if(!isWasmInitialized) {
5842 throw new Error("initializeWasm() must be awaited first!");
5844 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
5845 // debug statements here
5847 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
5849 export function ChannelMessageHandler_handle_closing_signed(this_arg: number, their_node_id: number, msg: number): void {
5850 if(!isWasmInitialized) {
5851 throw new Error("initializeWasm() must be awaited first!");
5853 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
5854 // debug statements here
5856 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
5858 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: number, their_node_id: number, msg: number): void {
5859 if(!isWasmInitialized) {
5860 throw new Error("initializeWasm() must be awaited first!");
5862 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
5863 // debug statements here
5865 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
5867 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: number, their_node_id: number, msg: number): void {
5868 if(!isWasmInitialized) {
5869 throw new Error("initializeWasm() must be awaited first!");
5871 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
5872 // debug statements here
5874 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
5876 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: number, their_node_id: number, msg: number): void {
5877 if(!isWasmInitialized) {
5878 throw new Error("initializeWasm() must be awaited first!");
5880 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
5881 // debug statements here
5883 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
5885 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: number, their_node_id: number, msg: number): void {
5886 if(!isWasmInitialized) {
5887 throw new Error("initializeWasm() must be awaited first!");
5889 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
5890 // debug statements here
5892 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
5894 export function ChannelMessageHandler_handle_commitment_signed(this_arg: number, their_node_id: number, msg: number): void {
5895 if(!isWasmInitialized) {
5896 throw new Error("initializeWasm() must be awaited first!");
5898 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
5899 // debug statements here
5901 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
5903 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: number, their_node_id: number, msg: number): void {
5904 if(!isWasmInitialized) {
5905 throw new Error("initializeWasm() must be awaited first!");
5907 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
5908 // debug statements here
5910 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
5912 export function ChannelMessageHandler_handle_update_fee(this_arg: number, their_node_id: number, msg: number): void {
5913 if(!isWasmInitialized) {
5914 throw new Error("initializeWasm() must be awaited first!");
5916 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
5917 // debug statements here
5919 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
5921 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: number, their_node_id: number, msg: number): void {
5922 if(!isWasmInitialized) {
5923 throw new Error("initializeWasm() must be awaited first!");
5925 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
5926 // debug statements here
5928 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
5930 export function ChannelMessageHandler_peer_disconnected(this_arg: number, their_node_id: number, no_connection_possible: boolean): void {
5931 if(!isWasmInitialized) {
5932 throw new Error("initializeWasm() must be awaited first!");
5934 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
5935 // debug statements here
5937 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
5939 export function ChannelMessageHandler_peer_connected(this_arg: number, their_node_id: number, msg: number): void {
5940 if(!isWasmInitialized) {
5941 throw new Error("initializeWasm() must be awaited first!");
5943 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
5944 // debug statements here
5946 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
5948 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: number, their_node_id: number, msg: number): void {
5949 if(!isWasmInitialized) {
5950 throw new Error("initializeWasm() must be awaited first!");
5952 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
5953 // debug statements here
5955 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
5957 export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: number, msg: number): void {
5958 if(!isWasmInitialized) {
5959 throw new Error("initializeWasm() must be awaited first!");
5961 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
5962 // debug statements here
5964 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
5966 export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: number, msg: number): void {
5967 if(!isWasmInitialized) {
5968 throw new Error("initializeWasm() must be awaited first!");
5970 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
5971 // debug statements here
5974 export interface LDKRoutingMessageHandler {
5975 handle_node_announcement (msg: number): number;
5976 handle_channel_announcement (msg: number): number;
5977 handle_channel_update (msg: number): number;
5978 get_next_channel_announcements (starting_point: bigint, batch_amount: number): number;
5979 get_next_node_announcements (starting_point: number, batch_amount: number): number;
5980 peer_connected (their_node_id: number, init: number): void;
5981 handle_reply_channel_range (their_node_id: number, msg: number): number;
5982 handle_reply_short_channel_ids_end (their_node_id: number, msg: number): number;
5983 handle_query_channel_range (their_node_id: number, msg: number): number;
5984 handle_query_short_channel_ids (their_node_id: number, msg: number): number;
5988 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
5989 if(!isWasmInitialized) {
5990 throw new Error("initializeWasm() must be awaited first!");
5992 var new_obj_idx = js_objs.length;
5993 for (var i = 0; i < js_objs.length; i++) {
5994 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5996 js_objs[i] = new WeakRef(impl);
5997 return wasm.TS_LDKRoutingMessageHandler_new(i);
5999 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
6001 export function RoutingMessageHandler_handle_node_announcement(this_arg: number, msg: number): number {
6002 if(!isWasmInitialized) {
6003 throw new Error("initializeWasm() must be awaited first!");
6005 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
6006 return nativeResponseValue;
6008 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
6010 export function RoutingMessageHandler_handle_channel_announcement(this_arg: number, msg: number): number {
6011 if(!isWasmInitialized) {
6012 throw new Error("initializeWasm() must be awaited first!");
6014 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
6015 return nativeResponseValue;
6017 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
6019 export function RoutingMessageHandler_handle_channel_update(this_arg: number, msg: number): number {
6020 if(!isWasmInitialized) {
6021 throw new Error("initializeWasm() must be awaited first!");
6023 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
6024 return nativeResponseValue;
6026 // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
6028 export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: bigint, batch_amount: number): number {
6029 if(!isWasmInitialized) {
6030 throw new Error("initializeWasm() must be awaited first!");
6032 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
6033 return nativeResponseValue;
6035 // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
6037 export function RoutingMessageHandler_get_next_node_announcements(this_arg: number, starting_point: number, batch_amount: number): number {
6038 if(!isWasmInitialized) {
6039 throw new Error("initializeWasm() must be awaited first!");
6041 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcements(this_arg, starting_point, batch_amount);
6042 return nativeResponseValue;
6044 // void RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
6046 export function RoutingMessageHandler_peer_connected(this_arg: number, their_node_id: number, init: number): void {
6047 if(!isWasmInitialized) {
6048 throw new Error("initializeWasm() must be awaited first!");
6050 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init);
6051 // debug statements here
6053 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
6055 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: number, their_node_id: number, msg: number): number {
6056 if(!isWasmInitialized) {
6057 throw new Error("initializeWasm() must be awaited first!");
6059 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
6060 return nativeResponseValue;
6062 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
6064 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: number, their_node_id: number, msg: number): number {
6065 if(!isWasmInitialized) {
6066 throw new Error("initializeWasm() must be awaited first!");
6068 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
6069 return nativeResponseValue;
6071 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
6073 export function RoutingMessageHandler_handle_query_channel_range(this_arg: number, their_node_id: number, msg: number): number {
6074 if(!isWasmInitialized) {
6075 throw new Error("initializeWasm() must be awaited first!");
6077 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
6078 return nativeResponseValue;
6080 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
6082 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: number, their_node_id: number, msg: number): number {
6083 if(!isWasmInitialized) {
6084 throw new Error("initializeWasm() must be awaited first!");
6086 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
6087 return nativeResponseValue;
6090 export interface LDKCustomMessageReader {
6091 read (message_type: number, buffer: number): number;
6095 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): number {
6096 if(!isWasmInitialized) {
6097 throw new Error("initializeWasm() must be awaited first!");
6099 var new_obj_idx = js_objs.length;
6100 for (var i = 0; i < js_objs.length; i++) {
6101 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6103 js_objs[i] = new WeakRef(impl);
6104 return wasm.TS_LDKCustomMessageReader_new(i);
6106 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
6108 export function CustomMessageReader_read(this_arg: number, message_type: number, buffer: number): number {
6109 if(!isWasmInitialized) {
6110 throw new Error("initializeWasm() must be awaited first!");
6112 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
6113 return nativeResponseValue;
6116 export interface LDKCustomMessageHandler {
6117 handle_custom_message (msg: number, sender_node_id: number): number;
6118 get_and_clear_pending_msg (): number;
6122 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): number {
6123 if(!isWasmInitialized) {
6124 throw new Error("initializeWasm() must be awaited first!");
6126 var new_obj_idx = js_objs.length;
6127 for (var i = 0; i < js_objs.length; i++) {
6128 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6130 js_objs[i] = new WeakRef(impl);
6131 return wasm.TS_LDKCustomMessageHandler_new(i);
6133 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
6135 export function CustomMessageHandler_handle_custom_message(this_arg: number, msg: number, sender_node_id: number): number {
6136 if(!isWasmInitialized) {
6137 throw new Error("initializeWasm() must be awaited first!");
6139 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
6140 return nativeResponseValue;
6142 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
6144 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: number): number {
6145 if(!isWasmInitialized) {
6146 throw new Error("initializeWasm() must be awaited first!");
6148 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
6149 return nativeResponseValue;
6152 export interface LDKSocketDescriptor {
6153 send_data (data: number, resume_read: boolean): number;
6154 disconnect_socket (): void;
6155 eq (other_arg: number): boolean;
6160 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): number {
6161 if(!isWasmInitialized) {
6162 throw new Error("initializeWasm() must be awaited first!");
6164 var new_obj_idx = js_objs.length;
6165 for (var i = 0; i < js_objs.length; i++) {
6166 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6168 js_objs[i] = new WeakRef(impl);
6169 return wasm.TS_LDKSocketDescriptor_new(i);
6171 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
6173 export function SocketDescriptor_send_data(this_arg: number, data: number, resume_read: boolean): number {
6174 if(!isWasmInitialized) {
6175 throw new Error("initializeWasm() must be awaited first!");
6177 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
6178 return nativeResponseValue;
6180 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
6182 export function SocketDescriptor_disconnect_socket(this_arg: number): void {
6183 if(!isWasmInitialized) {
6184 throw new Error("initializeWasm() must be awaited first!");
6186 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
6187 // debug statements here
6189 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
6191 export function SocketDescriptor_hash(this_arg: number): bigint {
6192 if(!isWasmInitialized) {
6193 throw new Error("initializeWasm() must be awaited first!");
6195 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
6196 return nativeResponseValue;
6199 export class LDKEffectiveCapacity {
6200 protected constructor() {}
6203 export function LDKEffectiveCapacity_ty_from_ptr(ptr: number): number {
6204 if(!isWasmInitialized) {
6205 throw new Error("initializeWasm() must be awaited first!");
6207 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
6208 return nativeResponseValue;
6211 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: number): bigint {
6212 if(!isWasmInitialized) {
6213 throw new Error("initializeWasm() must be awaited first!");
6215 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
6216 return nativeResponseValue;
6219 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: number): bigint {
6220 if(!isWasmInitialized) {
6221 throw new Error("initializeWasm() must be awaited first!");
6223 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
6224 return nativeResponseValue;
6227 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: number): bigint {
6228 if(!isWasmInitialized) {
6229 throw new Error("initializeWasm() must be awaited first!");
6231 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
6232 return nativeResponseValue;
6235 export interface LDKLockableScore {
6240 export function LDKLockableScore_new(impl: LDKLockableScore): number {
6241 if(!isWasmInitialized) {
6242 throw new Error("initializeWasm() must be awaited first!");
6244 var new_obj_idx = js_objs.length;
6245 for (var i = 0; i < js_objs.length; i++) {
6246 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6248 js_objs[i] = new WeakRef(impl);
6249 return wasm.TS_LDKLockableScore_new(i);
6251 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
6253 export function LockableScore_lock(this_arg: number): number {
6254 if(!isWasmInitialized) {
6255 throw new Error("initializeWasm() must be awaited first!");
6257 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
6258 return nativeResponseValue;
6261 export class LDKFallback {
6262 protected constructor() {}
6265 export function LDKFallback_ty_from_ptr(ptr: number): number {
6266 if(!isWasmInitialized) {
6267 throw new Error("initializeWasm() must be awaited first!");
6269 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
6270 return nativeResponseValue;
6273 export function LDKFallback_SegWitProgram_get_version(ptr: number): number {
6274 if(!isWasmInitialized) {
6275 throw new Error("initializeWasm() must be awaited first!");
6277 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
6278 return nativeResponseValue;
6281 export function LDKFallback_SegWitProgram_get_program(ptr: number): number {
6282 if(!isWasmInitialized) {
6283 throw new Error("initializeWasm() must be awaited first!");
6285 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
6286 return nativeResponseValue;
6289 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: number): number {
6290 if(!isWasmInitialized) {
6291 throw new Error("initializeWasm() must be awaited first!");
6293 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
6294 return nativeResponseValue;
6297 export function LDKFallback_ScriptHash_get_script_hash(ptr: number): number {
6298 if(!isWasmInitialized) {
6299 throw new Error("initializeWasm() must be awaited first!");
6301 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
6302 return nativeResponseValue;
6305 export interface LDKPayer {
6307 first_hops (): number;
6308 send_payment (route: number, payment_hash: number, payment_secret: number): number;
6309 send_spontaneous_payment (route: number, payment_preimage: number): number;
6310 retry_payment (route: number, payment_id: number): number;
6311 abandon_payment (payment_id: number): void;
6315 export function LDKPayer_new(impl: LDKPayer): number {
6316 if(!isWasmInitialized) {
6317 throw new Error("initializeWasm() must be awaited first!");
6319 var new_obj_idx = js_objs.length;
6320 for (var i = 0; i < js_objs.length; i++) {
6321 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6323 js_objs[i] = new WeakRef(impl);
6324 return wasm.TS_LDKPayer_new(i);
6326 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
6328 export function Payer_node_id(this_arg: number): number {
6329 if(!isWasmInitialized) {
6330 throw new Error("initializeWasm() must be awaited first!");
6332 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
6333 return nativeResponseValue;
6335 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
6337 export function Payer_first_hops(this_arg: number): number {
6338 if(!isWasmInitialized) {
6339 throw new Error("initializeWasm() must be awaited first!");
6341 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
6342 return nativeResponseValue;
6344 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret
6346 export function Payer_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
6347 if(!isWasmInitialized) {
6348 throw new Error("initializeWasm() must be awaited first!");
6350 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret);
6351 return nativeResponseValue;
6353 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage
6355 export function Payer_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
6356 if(!isWasmInitialized) {
6357 throw new Error("initializeWasm() must be awaited first!");
6359 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage);
6360 return nativeResponseValue;
6362 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
6364 export function Payer_retry_payment(this_arg: number, route: number, payment_id: number): number {
6365 if(!isWasmInitialized) {
6366 throw new Error("initializeWasm() must be awaited first!");
6368 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
6369 return nativeResponseValue;
6371 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
6373 export function Payer_abandon_payment(this_arg: number, payment_id: number): void {
6374 if(!isWasmInitialized) {
6375 throw new Error("initializeWasm() must be awaited first!");
6377 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
6378 // debug statements here
6381 export interface LDKRouter {
6382 find_route (payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number;
6386 export function LDKRouter_new(impl: LDKRouter): number {
6387 if(!isWasmInitialized) {
6388 throw new Error("initializeWasm() must be awaited first!");
6390 var new_obj_idx = js_objs.length;
6391 for (var i = 0; i < js_objs.length; i++) {
6392 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6394 js_objs[i] = new WeakRef(impl);
6395 return wasm.TS_LDKRouter_new(i);
6397 // 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
6399 export function Router_find_route(this_arg: number, payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number {
6400 if(!isWasmInitialized) {
6401 throw new Error("initializeWasm() must be awaited first!");
6403 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, payment_hash, first_hops, scorer);
6404 return nativeResponseValue;
6407 export class LDKRetry {
6408 protected constructor() {}
6411 export function LDKRetry_ty_from_ptr(ptr: number): number {
6412 if(!isWasmInitialized) {
6413 throw new Error("initializeWasm() must be awaited first!");
6415 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
6416 return nativeResponseValue;
6419 export function LDKRetry_Attempts_get_attempts(ptr: number): number {
6420 if(!isWasmInitialized) {
6421 throw new Error("initializeWasm() must be awaited first!");
6423 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
6424 return nativeResponseValue;
6426 // struct LDKStr _ldk_get_compiled_version(void);
6428 export function _ldk_get_compiled_version(): number {
6429 if(!isWasmInitialized) {
6430 throw new Error("initializeWasm() must be awaited first!");
6432 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
6433 return nativeResponseValue;
6435 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
6437 export function _ldk_c_bindings_get_compiled_version(): number {
6438 if(!isWasmInitialized) {
6439 throw new Error("initializeWasm() must be awaited first!");
6441 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
6442 return nativeResponseValue;
6444 // uintptr_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
6446 export function Bech32Error_clone_ptr(arg: number): number {
6447 if(!isWasmInitialized) {
6448 throw new Error("initializeWasm() must be awaited first!");
6450 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
6451 return nativeResponseValue;
6453 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
6455 export function Bech32Error_clone(orig: number): number {
6456 if(!isWasmInitialized) {
6457 throw new Error("initializeWasm() must be awaited first!");
6459 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
6460 return nativeResponseValue;
6462 // void Bech32Error_free(struct LDKBech32Error o);
6464 export function Bech32Error_free(o: number): void {
6465 if(!isWasmInitialized) {
6466 throw new Error("initializeWasm() must be awaited first!");
6468 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
6469 // debug statements here
6471 // void Transaction_free(struct LDKTransaction _res);
6473 export function Transaction_free(_res: number): void {
6474 if(!isWasmInitialized) {
6475 throw new Error("initializeWasm() must be awaited first!");
6477 const nativeResponseValue = wasm.TS_Transaction_free(_res);
6478 // debug statements here
6480 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
6482 export function TxOut_new(script_pubkey: number, value: bigint): number {
6483 if(!isWasmInitialized) {
6484 throw new Error("initializeWasm() must be awaited first!");
6486 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
6487 return nativeResponseValue;
6489 // void TxOut_free(struct LDKTxOut _res);
6491 export function TxOut_free(_res: number): void {
6492 if(!isWasmInitialized) {
6493 throw new Error("initializeWasm() must be awaited first!");
6495 const nativeResponseValue = wasm.TS_TxOut_free(_res);
6496 // debug statements here
6498 // uintptr_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
6500 export function TxOut_clone_ptr(arg: number): number {
6501 if(!isWasmInitialized) {
6502 throw new Error("initializeWasm() must be awaited first!");
6504 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
6505 return nativeResponseValue;
6507 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
6509 export function TxOut_clone(orig: number): number {
6510 if(!isWasmInitialized) {
6511 throw new Error("initializeWasm() must be awaited first!");
6513 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
6514 return nativeResponseValue;
6516 // void Str_free(struct LDKStr _res);
6518 export function Str_free(_res: number): void {
6519 if(!isWasmInitialized) {
6520 throw new Error("initializeWasm() must be awaited first!");
6522 const nativeResponseValue = wasm.TS_Str_free(_res);
6523 // debug statements here
6525 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
6527 export function CResult_NoneNoneZ_ok(): number {
6528 if(!isWasmInitialized) {
6529 throw new Error("initializeWasm() must be awaited first!");
6531 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
6532 return nativeResponseValue;
6534 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
6536 export function CResult_NoneNoneZ_err(): number {
6537 if(!isWasmInitialized) {
6538 throw new Error("initializeWasm() must be awaited first!");
6540 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
6541 return nativeResponseValue;
6543 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
6545 export function CResult_NoneNoneZ_is_ok(o: number): boolean {
6546 if(!isWasmInitialized) {
6547 throw new Error("initializeWasm() must be awaited first!");
6549 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
6550 return nativeResponseValue;
6552 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
6554 export function CResult_NoneNoneZ_free(_res: number): void {
6555 if(!isWasmInitialized) {
6556 throw new Error("initializeWasm() must be awaited first!");
6558 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
6559 // debug statements here
6561 // uintptr_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
6563 export function CResult_NoneNoneZ_clone_ptr(arg: number): number {
6564 if(!isWasmInitialized) {
6565 throw new Error("initializeWasm() must be awaited first!");
6567 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
6568 return nativeResponseValue;
6570 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
6572 export function CResult_NoneNoneZ_clone(orig: number): number {
6573 if(!isWasmInitialized) {
6574 throw new Error("initializeWasm() must be awaited first!");
6576 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
6577 return nativeResponseValue;
6579 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
6581 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: number): number {
6582 if(!isWasmInitialized) {
6583 throw new Error("initializeWasm() must be awaited first!");
6585 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
6586 return nativeResponseValue;
6588 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
6590 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: number): number {
6591 if(!isWasmInitialized) {
6592 throw new Error("initializeWasm() must be awaited first!");
6594 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
6595 return nativeResponseValue;
6597 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
6599 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: number): boolean {
6600 if(!isWasmInitialized) {
6601 throw new Error("initializeWasm() must be awaited first!");
6603 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
6604 return nativeResponseValue;
6606 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
6608 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: number): void {
6609 if(!isWasmInitialized) {
6610 throw new Error("initializeWasm() must be awaited first!");
6612 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
6613 // debug statements here
6615 // uintptr_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
6617 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: number): number {
6618 if(!isWasmInitialized) {
6619 throw new Error("initializeWasm() must be awaited first!");
6621 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
6622 return nativeResponseValue;
6624 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
6626 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: number): number {
6627 if(!isWasmInitialized) {
6628 throw new Error("initializeWasm() must be awaited first!");
6630 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
6631 return nativeResponseValue;
6633 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
6635 export function CResult_SecretKeyErrorZ_ok(o: number): number {
6636 if(!isWasmInitialized) {
6637 throw new Error("initializeWasm() must be awaited first!");
6639 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
6640 return nativeResponseValue;
6642 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
6644 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): number {
6645 if(!isWasmInitialized) {
6646 throw new Error("initializeWasm() must be awaited first!");
6648 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
6649 return nativeResponseValue;
6651 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
6653 export function CResult_SecretKeyErrorZ_is_ok(o: number): boolean {
6654 if(!isWasmInitialized) {
6655 throw new Error("initializeWasm() must be awaited first!");
6657 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
6658 return nativeResponseValue;
6660 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
6662 export function CResult_SecretKeyErrorZ_free(_res: number): void {
6663 if(!isWasmInitialized) {
6664 throw new Error("initializeWasm() must be awaited first!");
6666 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
6667 // debug statements here
6669 // uintptr_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg);
6671 export function CResult_SecretKeyErrorZ_clone_ptr(arg: number): number {
6672 if(!isWasmInitialized) {
6673 throw new Error("initializeWasm() must be awaited first!");
6675 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone_ptr(arg);
6676 return nativeResponseValue;
6678 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_clone(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR orig);
6680 export function CResult_SecretKeyErrorZ_clone(orig: number): number {
6681 if(!isWasmInitialized) {
6682 throw new Error("initializeWasm() must be awaited first!");
6684 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone(orig);
6685 return nativeResponseValue;
6687 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
6689 export function CResult_PublicKeyErrorZ_ok(o: number): number {
6690 if(!isWasmInitialized) {
6691 throw new Error("initializeWasm() must be awaited first!");
6693 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
6694 return nativeResponseValue;
6696 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
6698 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): number {
6699 if(!isWasmInitialized) {
6700 throw new Error("initializeWasm() must be awaited first!");
6702 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
6703 return nativeResponseValue;
6705 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
6707 export function CResult_PublicKeyErrorZ_is_ok(o: number): boolean {
6708 if(!isWasmInitialized) {
6709 throw new Error("initializeWasm() must be awaited first!");
6711 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
6712 return nativeResponseValue;
6714 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
6716 export function CResult_PublicKeyErrorZ_free(_res: number): void {
6717 if(!isWasmInitialized) {
6718 throw new Error("initializeWasm() must be awaited first!");
6720 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
6721 // debug statements here
6723 // uintptr_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
6725 export function CResult_PublicKeyErrorZ_clone_ptr(arg: number): number {
6726 if(!isWasmInitialized) {
6727 throw new Error("initializeWasm() must be awaited first!");
6729 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
6730 return nativeResponseValue;
6732 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
6734 export function CResult_PublicKeyErrorZ_clone(orig: number): number {
6735 if(!isWasmInitialized) {
6736 throw new Error("initializeWasm() must be awaited first!");
6738 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
6739 return nativeResponseValue;
6741 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
6743 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: number): number {
6744 if(!isWasmInitialized) {
6745 throw new Error("initializeWasm() must be awaited first!");
6747 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
6748 return nativeResponseValue;
6750 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
6752 export function CResult_TxCreationKeysDecodeErrorZ_err(e: number): number {
6753 if(!isWasmInitialized) {
6754 throw new Error("initializeWasm() must be awaited first!");
6756 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
6757 return nativeResponseValue;
6759 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
6761 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: number): boolean {
6762 if(!isWasmInitialized) {
6763 throw new Error("initializeWasm() must be awaited first!");
6765 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
6766 return nativeResponseValue;
6768 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
6770 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
6771 if(!isWasmInitialized) {
6772 throw new Error("initializeWasm() must be awaited first!");
6774 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
6775 // debug statements here
6777 // uintptr_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
6779 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: number): number {
6780 if(!isWasmInitialized) {
6781 throw new Error("initializeWasm() must be awaited first!");
6783 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
6784 return nativeResponseValue;
6786 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
6788 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: number): number {
6789 if(!isWasmInitialized) {
6790 throw new Error("initializeWasm() must be awaited first!");
6792 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
6793 return nativeResponseValue;
6795 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
6797 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: number): number {
6798 if(!isWasmInitialized) {
6799 throw new Error("initializeWasm() must be awaited first!");
6801 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
6802 return nativeResponseValue;
6804 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
6806 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: number): number {
6807 if(!isWasmInitialized) {
6808 throw new Error("initializeWasm() must be awaited first!");
6810 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
6811 return nativeResponseValue;
6813 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
6815 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: number): boolean {
6816 if(!isWasmInitialized) {
6817 throw new Error("initializeWasm() must be awaited first!");
6819 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
6820 return nativeResponseValue;
6822 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
6824 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: number): void {
6825 if(!isWasmInitialized) {
6826 throw new Error("initializeWasm() must be awaited first!");
6828 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
6829 // debug statements here
6831 // uintptr_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
6833 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: number): number {
6834 if(!isWasmInitialized) {
6835 throw new Error("initializeWasm() must be awaited first!");
6837 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
6838 return nativeResponseValue;
6840 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
6842 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: number): number {
6843 if(!isWasmInitialized) {
6844 throw new Error("initializeWasm() must be awaited first!");
6846 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
6847 return nativeResponseValue;
6849 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
6851 export function CResult_TxCreationKeysErrorZ_ok(o: number): number {
6852 if(!isWasmInitialized) {
6853 throw new Error("initializeWasm() must be awaited first!");
6855 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
6856 return nativeResponseValue;
6858 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
6860 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): number {
6861 if(!isWasmInitialized) {
6862 throw new Error("initializeWasm() must be awaited first!");
6864 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
6865 return nativeResponseValue;
6867 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
6869 export function CResult_TxCreationKeysErrorZ_is_ok(o: number): boolean {
6870 if(!isWasmInitialized) {
6871 throw new Error("initializeWasm() must be awaited first!");
6873 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
6874 return nativeResponseValue;
6876 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
6878 export function CResult_TxCreationKeysErrorZ_free(_res: number): void {
6879 if(!isWasmInitialized) {
6880 throw new Error("initializeWasm() must be awaited first!");
6882 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
6883 // debug statements here
6885 // uintptr_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
6887 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: number): number {
6888 if(!isWasmInitialized) {
6889 throw new Error("initializeWasm() must be awaited first!");
6891 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
6892 return nativeResponseValue;
6894 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
6896 export function CResult_TxCreationKeysErrorZ_clone(orig: number): number {
6897 if(!isWasmInitialized) {
6898 throw new Error("initializeWasm() must be awaited first!");
6900 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
6901 return nativeResponseValue;
6903 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
6905 export function COption_u32Z_some(o: number): number {
6906 if(!isWasmInitialized) {
6907 throw new Error("initializeWasm() must be awaited first!");
6909 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
6910 return nativeResponseValue;
6912 // struct LDKCOption_u32Z COption_u32Z_none(void);
6914 export function COption_u32Z_none(): number {
6915 if(!isWasmInitialized) {
6916 throw new Error("initializeWasm() must be awaited first!");
6918 const nativeResponseValue = wasm.TS_COption_u32Z_none();
6919 return nativeResponseValue;
6921 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
6923 export function COption_u32Z_free(_res: number): void {
6924 if(!isWasmInitialized) {
6925 throw new Error("initializeWasm() must be awaited first!");
6927 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
6928 // debug statements here
6930 // uintptr_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
6932 export function COption_u32Z_clone_ptr(arg: number): number {
6933 if(!isWasmInitialized) {
6934 throw new Error("initializeWasm() must be awaited first!");
6936 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
6937 return nativeResponseValue;
6939 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
6941 export function COption_u32Z_clone(orig: number): number {
6942 if(!isWasmInitialized) {
6943 throw new Error("initializeWasm() must be awaited first!");
6945 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
6946 return nativeResponseValue;
6948 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
6950 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
6951 if(!isWasmInitialized) {
6952 throw new Error("initializeWasm() must be awaited first!");
6954 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
6955 return nativeResponseValue;
6957 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
6959 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: number): number {
6960 if(!isWasmInitialized) {
6961 throw new Error("initializeWasm() must be awaited first!");
6963 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
6964 return nativeResponseValue;
6966 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
6968 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: number): boolean {
6969 if(!isWasmInitialized) {
6970 throw new Error("initializeWasm() must be awaited first!");
6972 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
6973 return nativeResponseValue;
6975 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
6977 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: number): void {
6978 if(!isWasmInitialized) {
6979 throw new Error("initializeWasm() must be awaited first!");
6981 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
6982 // debug statements here
6984 // uintptr_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
6986 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: number): number {
6987 if(!isWasmInitialized) {
6988 throw new Error("initializeWasm() must be awaited first!");
6990 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
6991 return nativeResponseValue;
6993 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
6995 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: number): number {
6996 if(!isWasmInitialized) {
6997 throw new Error("initializeWasm() must be awaited first!");
6999 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
7000 return nativeResponseValue;
7002 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
7004 export function COption_NoneZ_some(): COption_NoneZ {
7005 if(!isWasmInitialized) {
7006 throw new Error("initializeWasm() must be awaited first!");
7008 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
7009 return nativeResponseValue;
7011 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
7013 export function COption_NoneZ_none(): COption_NoneZ {
7014 if(!isWasmInitialized) {
7015 throw new Error("initializeWasm() must be awaited first!");
7017 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
7018 return nativeResponseValue;
7020 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
7022 export function COption_NoneZ_free(_res: COption_NoneZ): void {
7023 if(!isWasmInitialized) {
7024 throw new Error("initializeWasm() must be awaited first!");
7026 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
7027 // debug statements here
7029 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
7031 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
7032 if(!isWasmInitialized) {
7033 throw new Error("initializeWasm() must be awaited first!");
7035 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
7036 return nativeResponseValue;
7038 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7040 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: number): number {
7041 if(!isWasmInitialized) {
7042 throw new Error("initializeWasm() must be awaited first!");
7044 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
7045 return nativeResponseValue;
7047 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7049 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
7050 if(!isWasmInitialized) {
7051 throw new Error("initializeWasm() must be awaited first!");
7053 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
7054 return nativeResponseValue;
7056 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
7058 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
7059 if(!isWasmInitialized) {
7060 throw new Error("initializeWasm() must be awaited first!");
7062 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
7063 // debug statements here
7065 // uintptr_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7067 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
7068 if(!isWasmInitialized) {
7069 throw new Error("initializeWasm() must be awaited first!");
7071 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7072 return nativeResponseValue;
7074 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7076 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
7077 if(!isWasmInitialized) {
7078 throw new Error("initializeWasm() must be awaited first!");
7080 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
7081 return nativeResponseValue;
7083 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
7085 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
7086 if(!isWasmInitialized) {
7087 throw new Error("initializeWasm() must be awaited first!");
7089 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
7090 return nativeResponseValue;
7092 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7094 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: number): number {
7095 if(!isWasmInitialized) {
7096 throw new Error("initializeWasm() must be awaited first!");
7098 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
7099 return nativeResponseValue;
7101 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7103 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
7104 if(!isWasmInitialized) {
7105 throw new Error("initializeWasm() must be awaited first!");
7107 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
7108 return nativeResponseValue;
7110 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
7112 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
7113 if(!isWasmInitialized) {
7114 throw new Error("initializeWasm() must be awaited first!");
7116 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
7117 // debug statements here
7119 // uintptr_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7121 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
7122 if(!isWasmInitialized) {
7123 throw new Error("initializeWasm() must be awaited first!");
7125 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7126 return nativeResponseValue;
7128 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7130 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
7131 if(!isWasmInitialized) {
7132 throw new Error("initializeWasm() must be awaited first!");
7134 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
7135 return nativeResponseValue;
7137 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
7139 export function CVec_SignatureZ_free(_res: number): void {
7140 if(!isWasmInitialized) {
7141 throw new Error("initializeWasm() must be awaited first!");
7143 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
7144 // debug statements here
7146 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
7148 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7149 if(!isWasmInitialized) {
7150 throw new Error("initializeWasm() must be awaited first!");
7152 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
7153 return nativeResponseValue;
7155 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7157 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: number): number {
7158 if(!isWasmInitialized) {
7159 throw new Error("initializeWasm() must be awaited first!");
7161 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
7162 return nativeResponseValue;
7164 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7166 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7167 if(!isWasmInitialized) {
7168 throw new Error("initializeWasm() must be awaited first!");
7170 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
7171 return nativeResponseValue;
7173 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
7175 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7176 if(!isWasmInitialized) {
7177 throw new Error("initializeWasm() must be awaited first!");
7179 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
7180 // debug statements here
7182 // uintptr_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7184 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7185 if(!isWasmInitialized) {
7186 throw new Error("initializeWasm() must be awaited first!");
7188 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7189 return nativeResponseValue;
7191 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7193 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7194 if(!isWasmInitialized) {
7195 throw new Error("initializeWasm() must be awaited first!");
7197 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
7198 return nativeResponseValue;
7200 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
7202 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7203 if(!isWasmInitialized) {
7204 throw new Error("initializeWasm() must be awaited first!");
7206 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
7207 return nativeResponseValue;
7209 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7211 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: number): number {
7212 if(!isWasmInitialized) {
7213 throw new Error("initializeWasm() must be awaited first!");
7215 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
7216 return nativeResponseValue;
7218 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7220 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7221 if(!isWasmInitialized) {
7222 throw new Error("initializeWasm() must be awaited first!");
7224 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
7225 return nativeResponseValue;
7227 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
7229 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7230 if(!isWasmInitialized) {
7231 throw new Error("initializeWasm() must be awaited first!");
7233 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
7234 // debug statements here
7236 // uintptr_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7238 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7239 if(!isWasmInitialized) {
7240 throw new Error("initializeWasm() must be awaited first!");
7242 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7243 return nativeResponseValue;
7245 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7247 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7248 if(!isWasmInitialized) {
7249 throw new Error("initializeWasm() must be awaited first!");
7251 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
7252 return nativeResponseValue;
7254 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
7256 export function CResult_TrustedClosingTransactionNoneZ_ok(o: number): number {
7257 if(!isWasmInitialized) {
7258 throw new Error("initializeWasm() must be awaited first!");
7260 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
7261 return nativeResponseValue;
7263 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
7265 export function CResult_TrustedClosingTransactionNoneZ_err(): number {
7266 if(!isWasmInitialized) {
7267 throw new Error("initializeWasm() must be awaited first!");
7269 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
7270 return nativeResponseValue;
7272 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
7274 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: number): boolean {
7275 if(!isWasmInitialized) {
7276 throw new Error("initializeWasm() must be awaited first!");
7278 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
7279 return nativeResponseValue;
7281 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
7283 export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
7284 if(!isWasmInitialized) {
7285 throw new Error("initializeWasm() must be awaited first!");
7287 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
7288 // debug statements here
7290 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
7292 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: number): number {
7293 if(!isWasmInitialized) {
7294 throw new Error("initializeWasm() must be awaited first!");
7296 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
7297 return nativeResponseValue;
7299 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7301 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: number): number {
7302 if(!isWasmInitialized) {
7303 throw new Error("initializeWasm() must be awaited first!");
7305 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
7306 return nativeResponseValue;
7308 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7310 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7311 if(!isWasmInitialized) {
7312 throw new Error("initializeWasm() must be awaited first!");
7314 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
7315 return nativeResponseValue;
7317 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
7319 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: number): void {
7320 if(!isWasmInitialized) {
7321 throw new Error("initializeWasm() must be awaited first!");
7323 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
7324 // debug statements here
7326 // uintptr_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7328 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7329 if(!isWasmInitialized) {
7330 throw new Error("initializeWasm() must be awaited first!");
7332 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7333 return nativeResponseValue;
7335 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7337 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7338 if(!isWasmInitialized) {
7339 throw new Error("initializeWasm() must be awaited first!");
7341 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
7342 return nativeResponseValue;
7344 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
7346 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
7347 if(!isWasmInitialized) {
7348 throw new Error("initializeWasm() must be awaited first!");
7350 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
7351 return nativeResponseValue;
7353 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
7355 export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
7356 if(!isWasmInitialized) {
7357 throw new Error("initializeWasm() must be awaited first!");
7359 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
7360 return nativeResponseValue;
7362 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
7364 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: number): boolean {
7365 if(!isWasmInitialized) {
7366 throw new Error("initializeWasm() must be awaited first!");
7368 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
7369 return nativeResponseValue;
7371 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
7373 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
7374 if(!isWasmInitialized) {
7375 throw new Error("initializeWasm() must be awaited first!");
7377 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
7378 // debug statements here
7380 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
7382 export function CResult_CVec_SignatureZNoneZ_ok(o: number): number {
7383 if(!isWasmInitialized) {
7384 throw new Error("initializeWasm() must be awaited first!");
7386 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
7387 return nativeResponseValue;
7389 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
7391 export function CResult_CVec_SignatureZNoneZ_err(): number {
7392 if(!isWasmInitialized) {
7393 throw new Error("initializeWasm() must be awaited first!");
7395 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
7396 return nativeResponseValue;
7398 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
7400 export function CResult_CVec_SignatureZNoneZ_is_ok(o: number): boolean {
7401 if(!isWasmInitialized) {
7402 throw new Error("initializeWasm() must be awaited first!");
7404 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
7405 return nativeResponseValue;
7407 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
7409 export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
7410 if(!isWasmInitialized) {
7411 throw new Error("initializeWasm() must be awaited first!");
7413 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
7414 // debug statements here
7416 // uintptr_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
7418 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: number): number {
7419 if(!isWasmInitialized) {
7420 throw new Error("initializeWasm() must be awaited first!");
7422 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
7423 return nativeResponseValue;
7425 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
7427 export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
7428 if(!isWasmInitialized) {
7429 throw new Error("initializeWasm() must be awaited first!");
7431 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
7432 return nativeResponseValue;
7434 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
7436 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: number): number {
7437 if(!isWasmInitialized) {
7438 throw new Error("initializeWasm() must be awaited first!");
7440 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
7441 return nativeResponseValue;
7443 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
7445 export function CResult_ShutdownScriptDecodeErrorZ_err(e: number): number {
7446 if(!isWasmInitialized) {
7447 throw new Error("initializeWasm() must be awaited first!");
7449 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
7450 return nativeResponseValue;
7452 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
7454 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: number): boolean {
7455 if(!isWasmInitialized) {
7456 throw new Error("initializeWasm() must be awaited first!");
7458 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
7459 return nativeResponseValue;
7461 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
7463 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
7464 if(!isWasmInitialized) {
7465 throw new Error("initializeWasm() must be awaited first!");
7467 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
7468 // debug statements here
7470 // uintptr_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
7472 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: number): number {
7473 if(!isWasmInitialized) {
7474 throw new Error("initializeWasm() must be awaited first!");
7476 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
7477 return nativeResponseValue;
7479 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
7481 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
7482 if(!isWasmInitialized) {
7483 throw new Error("initializeWasm() must be awaited first!");
7485 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
7486 return nativeResponseValue;
7488 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
7490 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: number): number {
7491 if(!isWasmInitialized) {
7492 throw new Error("initializeWasm() must be awaited first!");
7494 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
7495 return nativeResponseValue;
7497 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
7499 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: number): number {
7500 if(!isWasmInitialized) {
7501 throw new Error("initializeWasm() must be awaited first!");
7503 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
7504 return nativeResponseValue;
7506 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
7508 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: number): boolean {
7509 if(!isWasmInitialized) {
7510 throw new Error("initializeWasm() must be awaited first!");
7512 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
7513 return nativeResponseValue;
7515 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
7517 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
7518 if(!isWasmInitialized) {
7519 throw new Error("initializeWasm() must be awaited first!");
7521 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
7522 // debug statements here
7524 // uintptr_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
7526 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: number): number {
7527 if(!isWasmInitialized) {
7528 throw new Error("initializeWasm() must be awaited first!");
7530 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
7531 return nativeResponseValue;
7533 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
7535 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: number): number {
7536 if(!isWasmInitialized) {
7537 throw new Error("initializeWasm() must be awaited first!");
7539 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
7540 return nativeResponseValue;
7542 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
7544 export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
7545 if(!isWasmInitialized) {
7546 throw new Error("initializeWasm() must be awaited first!");
7548 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
7549 return nativeResponseValue;
7551 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
7553 export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
7554 if(!isWasmInitialized) {
7555 throw new Error("initializeWasm() must be awaited first!");
7557 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
7558 return nativeResponseValue;
7560 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
7562 export function CResult_RouteHopDecodeErrorZ_is_ok(o: number): boolean {
7563 if(!isWasmInitialized) {
7564 throw new Error("initializeWasm() must be awaited first!");
7566 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
7567 return nativeResponseValue;
7569 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
7571 export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
7572 if(!isWasmInitialized) {
7573 throw new Error("initializeWasm() must be awaited first!");
7575 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
7576 // debug statements here
7578 // uintptr_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
7580 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: number): number {
7581 if(!isWasmInitialized) {
7582 throw new Error("initializeWasm() must be awaited first!");
7584 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
7585 return nativeResponseValue;
7587 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
7589 export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
7590 if(!isWasmInitialized) {
7591 throw new Error("initializeWasm() must be awaited first!");
7593 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
7594 return nativeResponseValue;
7596 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
7598 export function CVec_RouteHopZ_free(_res: number): void {
7599 if(!isWasmInitialized) {
7600 throw new Error("initializeWasm() must be awaited first!");
7602 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
7603 // debug statements here
7605 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
7607 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
7608 if(!isWasmInitialized) {
7609 throw new Error("initializeWasm() must be awaited first!");
7611 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
7612 // debug statements here
7614 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
7616 export function CResult_RouteDecodeErrorZ_ok(o: number): number {
7617 if(!isWasmInitialized) {
7618 throw new Error("initializeWasm() must be awaited first!");
7620 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
7621 return nativeResponseValue;
7623 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
7625 export function CResult_RouteDecodeErrorZ_err(e: number): number {
7626 if(!isWasmInitialized) {
7627 throw new Error("initializeWasm() must be awaited first!");
7629 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
7630 return nativeResponseValue;
7632 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
7634 export function CResult_RouteDecodeErrorZ_is_ok(o: number): boolean {
7635 if(!isWasmInitialized) {
7636 throw new Error("initializeWasm() must be awaited first!");
7638 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
7639 return nativeResponseValue;
7641 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
7643 export function CResult_RouteDecodeErrorZ_free(_res: number): void {
7644 if(!isWasmInitialized) {
7645 throw new Error("initializeWasm() must be awaited first!");
7647 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
7648 // debug statements here
7650 // uintptr_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
7652 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: number): number {
7653 if(!isWasmInitialized) {
7654 throw new Error("initializeWasm() must be awaited first!");
7656 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
7657 return nativeResponseValue;
7659 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
7661 export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
7662 if(!isWasmInitialized) {
7663 throw new Error("initializeWasm() must be awaited first!");
7665 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
7666 return nativeResponseValue;
7668 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
7670 export function CResult_RouteParametersDecodeErrorZ_ok(o: number): number {
7671 if(!isWasmInitialized) {
7672 throw new Error("initializeWasm() must be awaited first!");
7674 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
7675 return nativeResponseValue;
7677 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
7679 export function CResult_RouteParametersDecodeErrorZ_err(e: number): number {
7680 if(!isWasmInitialized) {
7681 throw new Error("initializeWasm() must be awaited first!");
7683 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
7684 return nativeResponseValue;
7686 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
7688 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: number): boolean {
7689 if(!isWasmInitialized) {
7690 throw new Error("initializeWasm() must be awaited first!");
7692 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
7693 return nativeResponseValue;
7695 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
7697 export function CResult_RouteParametersDecodeErrorZ_free(_res: number): void {
7698 if(!isWasmInitialized) {
7699 throw new Error("initializeWasm() must be awaited first!");
7701 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
7702 // debug statements here
7704 // uintptr_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
7706 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: number): number {
7707 if(!isWasmInitialized) {
7708 throw new Error("initializeWasm() must be awaited first!");
7710 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
7711 return nativeResponseValue;
7713 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
7715 export function CResult_RouteParametersDecodeErrorZ_clone(orig: number): number {
7716 if(!isWasmInitialized) {
7717 throw new Error("initializeWasm() must be awaited first!");
7719 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
7720 return nativeResponseValue;
7722 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
7724 export function CVec_RouteHintZ_free(_res: number): void {
7725 if(!isWasmInitialized) {
7726 throw new Error("initializeWasm() must be awaited first!");
7728 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
7729 // debug statements here
7731 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
7733 export function COption_u64Z_some(o: bigint): number {
7734 if(!isWasmInitialized) {
7735 throw new Error("initializeWasm() must be awaited first!");
7737 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
7738 return nativeResponseValue;
7740 // struct LDKCOption_u64Z COption_u64Z_none(void);
7742 export function COption_u64Z_none(): number {
7743 if(!isWasmInitialized) {
7744 throw new Error("initializeWasm() must be awaited first!");
7746 const nativeResponseValue = wasm.TS_COption_u64Z_none();
7747 return nativeResponseValue;
7749 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
7751 export function COption_u64Z_free(_res: number): void {
7752 if(!isWasmInitialized) {
7753 throw new Error("initializeWasm() must be awaited first!");
7755 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
7756 // debug statements here
7758 // uintptr_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
7760 export function COption_u64Z_clone_ptr(arg: number): number {
7761 if(!isWasmInitialized) {
7762 throw new Error("initializeWasm() must be awaited first!");
7764 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
7765 return nativeResponseValue;
7767 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
7769 export function COption_u64Z_clone(orig: number): number {
7770 if(!isWasmInitialized) {
7771 throw new Error("initializeWasm() must be awaited first!");
7773 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
7774 return nativeResponseValue;
7776 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
7778 export function CResult_PaymentParametersDecodeErrorZ_ok(o: number): number {
7779 if(!isWasmInitialized) {
7780 throw new Error("initializeWasm() must be awaited first!");
7782 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
7783 return nativeResponseValue;
7785 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
7787 export function CResult_PaymentParametersDecodeErrorZ_err(e: number): number {
7788 if(!isWasmInitialized) {
7789 throw new Error("initializeWasm() must be awaited first!");
7791 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
7792 return nativeResponseValue;
7794 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
7796 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: number): boolean {
7797 if(!isWasmInitialized) {
7798 throw new Error("initializeWasm() must be awaited first!");
7800 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
7801 return nativeResponseValue;
7803 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
7805 export function CResult_PaymentParametersDecodeErrorZ_free(_res: number): void {
7806 if(!isWasmInitialized) {
7807 throw new Error("initializeWasm() must be awaited first!");
7809 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
7810 // debug statements here
7812 // uintptr_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
7814 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: number): number {
7815 if(!isWasmInitialized) {
7816 throw new Error("initializeWasm() must be awaited first!");
7818 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
7819 return nativeResponseValue;
7821 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
7823 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: number): number {
7824 if(!isWasmInitialized) {
7825 throw new Error("initializeWasm() must be awaited first!");
7827 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
7828 return nativeResponseValue;
7830 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
7832 export function CVec_RouteHintHopZ_free(_res: number): void {
7833 if(!isWasmInitialized) {
7834 throw new Error("initializeWasm() must be awaited first!");
7836 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
7837 // debug statements here
7839 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
7841 export function CResult_RouteHintDecodeErrorZ_ok(o: number): number {
7842 if(!isWasmInitialized) {
7843 throw new Error("initializeWasm() must be awaited first!");
7845 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
7846 return nativeResponseValue;
7848 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
7850 export function CResult_RouteHintDecodeErrorZ_err(e: number): number {
7851 if(!isWasmInitialized) {
7852 throw new Error("initializeWasm() must be awaited first!");
7854 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
7855 return nativeResponseValue;
7857 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
7859 export function CResult_RouteHintDecodeErrorZ_is_ok(o: number): boolean {
7860 if(!isWasmInitialized) {
7861 throw new Error("initializeWasm() must be awaited first!");
7863 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
7864 return nativeResponseValue;
7866 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
7868 export function CResult_RouteHintDecodeErrorZ_free(_res: number): void {
7869 if(!isWasmInitialized) {
7870 throw new Error("initializeWasm() must be awaited first!");
7872 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
7873 // debug statements here
7875 // uintptr_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
7877 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: number): number {
7878 if(!isWasmInitialized) {
7879 throw new Error("initializeWasm() must be awaited first!");
7881 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
7882 return nativeResponseValue;
7884 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
7886 export function CResult_RouteHintDecodeErrorZ_clone(orig: number): number {
7887 if(!isWasmInitialized) {
7888 throw new Error("initializeWasm() must be awaited first!");
7890 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
7891 return nativeResponseValue;
7893 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
7895 export function CResult_RouteHintHopDecodeErrorZ_ok(o: number): number {
7896 if(!isWasmInitialized) {
7897 throw new Error("initializeWasm() must be awaited first!");
7899 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
7900 return nativeResponseValue;
7902 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
7904 export function CResult_RouteHintHopDecodeErrorZ_err(e: number): number {
7905 if(!isWasmInitialized) {
7906 throw new Error("initializeWasm() must be awaited first!");
7908 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
7909 return nativeResponseValue;
7911 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
7913 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: number): boolean {
7914 if(!isWasmInitialized) {
7915 throw new Error("initializeWasm() must be awaited first!");
7917 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
7918 return nativeResponseValue;
7920 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
7922 export function CResult_RouteHintHopDecodeErrorZ_free(_res: number): void {
7923 if(!isWasmInitialized) {
7924 throw new Error("initializeWasm() must be awaited first!");
7926 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
7927 // debug statements here
7929 // uintptr_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
7931 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: number): number {
7932 if(!isWasmInitialized) {
7933 throw new Error("initializeWasm() must be awaited first!");
7935 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
7936 return nativeResponseValue;
7938 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
7940 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: number): number {
7941 if(!isWasmInitialized) {
7942 throw new Error("initializeWasm() must be awaited first!");
7944 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
7945 return nativeResponseValue;
7947 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
7949 export function CVec_ChannelDetailsZ_free(_res: number): void {
7950 if(!isWasmInitialized) {
7951 throw new Error("initializeWasm() must be awaited first!");
7953 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
7954 // debug statements here
7956 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
7958 export function CResult_RouteLightningErrorZ_ok(o: number): number {
7959 if(!isWasmInitialized) {
7960 throw new Error("initializeWasm() must be awaited first!");
7962 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
7963 return nativeResponseValue;
7965 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
7967 export function CResult_RouteLightningErrorZ_err(e: number): number {
7968 if(!isWasmInitialized) {
7969 throw new Error("initializeWasm() must be awaited first!");
7971 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
7972 return nativeResponseValue;
7974 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
7976 export function CResult_RouteLightningErrorZ_is_ok(o: number): boolean {
7977 if(!isWasmInitialized) {
7978 throw new Error("initializeWasm() must be awaited first!");
7980 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
7981 return nativeResponseValue;
7983 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
7985 export function CResult_RouteLightningErrorZ_free(_res: number): void {
7986 if(!isWasmInitialized) {
7987 throw new Error("initializeWasm() must be awaited first!");
7989 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
7990 // debug statements here
7992 // uintptr_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
7994 export function CResult_RouteLightningErrorZ_clone_ptr(arg: number): number {
7995 if(!isWasmInitialized) {
7996 throw new Error("initializeWasm() must be awaited first!");
7998 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
7999 return nativeResponseValue;
8001 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
8003 export function CResult_RouteLightningErrorZ_clone(orig: number): number {
8004 if(!isWasmInitialized) {
8005 throw new Error("initializeWasm() must be awaited first!");
8007 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
8008 return nativeResponseValue;
8010 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
8012 export function CVec_PublicKeyZ_free(_res: number): void {
8013 if(!isWasmInitialized) {
8014 throw new Error("initializeWasm() must be awaited first!");
8016 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
8017 // debug statements here
8019 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
8021 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: number): number {
8022 if(!isWasmInitialized) {
8023 throw new Error("initializeWasm() must be awaited first!");
8025 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
8026 return nativeResponseValue;
8028 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
8030 export function CResult_PaymentPurposeDecodeErrorZ_err(e: number): number {
8031 if(!isWasmInitialized) {
8032 throw new Error("initializeWasm() must be awaited first!");
8034 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
8035 return nativeResponseValue;
8037 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
8039 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: number): boolean {
8040 if(!isWasmInitialized) {
8041 throw new Error("initializeWasm() must be awaited first!");
8043 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
8044 return nativeResponseValue;
8046 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
8048 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: number): void {
8049 if(!isWasmInitialized) {
8050 throw new Error("initializeWasm() must be awaited first!");
8052 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
8053 // debug statements here
8055 // uintptr_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
8057 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: number): number {
8058 if(!isWasmInitialized) {
8059 throw new Error("initializeWasm() must be awaited first!");
8061 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
8062 return nativeResponseValue;
8064 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
8066 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: number): number {
8067 if(!isWasmInitialized) {
8068 throw new Error("initializeWasm() must be awaited first!");
8070 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
8071 return nativeResponseValue;
8073 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
8075 export function COption_ClosureReasonZ_some(o: number): number {
8076 if(!isWasmInitialized) {
8077 throw new Error("initializeWasm() must be awaited first!");
8079 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
8080 return nativeResponseValue;
8082 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
8084 export function COption_ClosureReasonZ_none(): number {
8085 if(!isWasmInitialized) {
8086 throw new Error("initializeWasm() must be awaited first!");
8088 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
8089 return nativeResponseValue;
8091 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
8093 export function COption_ClosureReasonZ_free(_res: number): void {
8094 if(!isWasmInitialized) {
8095 throw new Error("initializeWasm() must be awaited first!");
8097 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
8098 // debug statements here
8100 // uintptr_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
8102 export function COption_ClosureReasonZ_clone_ptr(arg: number): number {
8103 if(!isWasmInitialized) {
8104 throw new Error("initializeWasm() must be awaited first!");
8106 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
8107 return nativeResponseValue;
8109 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
8111 export function COption_ClosureReasonZ_clone(orig: number): number {
8112 if(!isWasmInitialized) {
8113 throw new Error("initializeWasm() must be awaited first!");
8115 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
8116 return nativeResponseValue;
8118 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
8120 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: number): number {
8121 if(!isWasmInitialized) {
8122 throw new Error("initializeWasm() must be awaited first!");
8124 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
8125 return nativeResponseValue;
8127 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
8129 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: number): number {
8130 if(!isWasmInitialized) {
8131 throw new Error("initializeWasm() must be awaited first!");
8133 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
8134 return nativeResponseValue;
8136 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
8138 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: number): boolean {
8139 if(!isWasmInitialized) {
8140 throw new Error("initializeWasm() must be awaited first!");
8142 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
8143 return nativeResponseValue;
8145 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
8147 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: number): void {
8148 if(!isWasmInitialized) {
8149 throw new Error("initializeWasm() must be awaited first!");
8151 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
8152 // debug statements here
8154 // uintptr_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
8156 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: number): number {
8157 if(!isWasmInitialized) {
8158 throw new Error("initializeWasm() must be awaited first!");
8160 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
8161 return nativeResponseValue;
8163 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
8165 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: number): number {
8166 if(!isWasmInitialized) {
8167 throw new Error("initializeWasm() must be awaited first!");
8169 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
8170 return nativeResponseValue;
8172 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
8174 export function COption_NetworkUpdateZ_some(o: number): number {
8175 if(!isWasmInitialized) {
8176 throw new Error("initializeWasm() must be awaited first!");
8178 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
8179 return nativeResponseValue;
8181 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
8183 export function COption_NetworkUpdateZ_none(): number {
8184 if(!isWasmInitialized) {
8185 throw new Error("initializeWasm() must be awaited first!");
8187 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
8188 return nativeResponseValue;
8190 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
8192 export function COption_NetworkUpdateZ_free(_res: number): void {
8193 if(!isWasmInitialized) {
8194 throw new Error("initializeWasm() must be awaited first!");
8196 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
8197 // debug statements here
8199 // uintptr_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
8201 export function COption_NetworkUpdateZ_clone_ptr(arg: number): number {
8202 if(!isWasmInitialized) {
8203 throw new Error("initializeWasm() must be awaited first!");
8205 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
8206 return nativeResponseValue;
8208 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
8210 export function COption_NetworkUpdateZ_clone(orig: number): number {
8211 if(!isWasmInitialized) {
8212 throw new Error("initializeWasm() must be awaited first!");
8214 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
8215 return nativeResponseValue;
8217 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
8219 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
8220 if(!isWasmInitialized) {
8221 throw new Error("initializeWasm() must be awaited first!");
8223 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
8224 // debug statements here
8226 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
8228 export function COption_EventZ_some(o: number): number {
8229 if(!isWasmInitialized) {
8230 throw new Error("initializeWasm() must be awaited first!");
8232 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
8233 return nativeResponseValue;
8235 // struct LDKCOption_EventZ COption_EventZ_none(void);
8237 export function COption_EventZ_none(): number {
8238 if(!isWasmInitialized) {
8239 throw new Error("initializeWasm() must be awaited first!");
8241 const nativeResponseValue = wasm.TS_COption_EventZ_none();
8242 return nativeResponseValue;
8244 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
8246 export function COption_EventZ_free(_res: number): void {
8247 if(!isWasmInitialized) {
8248 throw new Error("initializeWasm() must be awaited first!");
8250 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
8251 // debug statements here
8253 // uintptr_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
8255 export function COption_EventZ_clone_ptr(arg: number): number {
8256 if(!isWasmInitialized) {
8257 throw new Error("initializeWasm() must be awaited first!");
8259 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
8260 return nativeResponseValue;
8262 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
8264 export function COption_EventZ_clone(orig: number): number {
8265 if(!isWasmInitialized) {
8266 throw new Error("initializeWasm() must be awaited first!");
8268 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
8269 return nativeResponseValue;
8271 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
8273 export function CResult_COption_EventZDecodeErrorZ_ok(o: number): number {
8274 if(!isWasmInitialized) {
8275 throw new Error("initializeWasm() must be awaited first!");
8277 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
8278 return nativeResponseValue;
8280 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
8282 export function CResult_COption_EventZDecodeErrorZ_err(e: number): number {
8283 if(!isWasmInitialized) {
8284 throw new Error("initializeWasm() must be awaited first!");
8286 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
8287 return nativeResponseValue;
8289 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
8291 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: number): boolean {
8292 if(!isWasmInitialized) {
8293 throw new Error("initializeWasm() must be awaited first!");
8295 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
8296 return nativeResponseValue;
8298 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
8300 export function CResult_COption_EventZDecodeErrorZ_free(_res: number): void {
8301 if(!isWasmInitialized) {
8302 throw new Error("initializeWasm() must be awaited first!");
8304 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
8305 // debug statements here
8307 // uintptr_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
8309 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: number): number {
8310 if(!isWasmInitialized) {
8311 throw new Error("initializeWasm() must be awaited first!");
8313 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
8314 return nativeResponseValue;
8316 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
8318 export function CResult_COption_EventZDecodeErrorZ_clone(orig: number): number {
8319 if(!isWasmInitialized) {
8320 throw new Error("initializeWasm() must be awaited first!");
8322 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
8323 return nativeResponseValue;
8325 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
8327 export function CVec_MessageSendEventZ_free(_res: number): void {
8328 if(!isWasmInitialized) {
8329 throw new Error("initializeWasm() must be awaited first!");
8331 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
8332 // debug statements here
8334 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
8336 export function CResult_TxOutAccessErrorZ_ok(o: number): number {
8337 if(!isWasmInitialized) {
8338 throw new Error("initializeWasm() must be awaited first!");
8340 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
8341 return nativeResponseValue;
8343 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
8345 export function CResult_TxOutAccessErrorZ_err(e: AccessError): number {
8346 if(!isWasmInitialized) {
8347 throw new Error("initializeWasm() must be awaited first!");
8349 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
8350 return nativeResponseValue;
8352 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
8354 export function CResult_TxOutAccessErrorZ_is_ok(o: number): boolean {
8355 if(!isWasmInitialized) {
8356 throw new Error("initializeWasm() must be awaited first!");
8358 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
8359 return nativeResponseValue;
8361 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
8363 export function CResult_TxOutAccessErrorZ_free(_res: number): void {
8364 if(!isWasmInitialized) {
8365 throw new Error("initializeWasm() must be awaited first!");
8367 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
8368 // debug statements here
8370 // uintptr_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
8372 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: number): number {
8373 if(!isWasmInitialized) {
8374 throw new Error("initializeWasm() must be awaited first!");
8376 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
8377 return nativeResponseValue;
8379 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
8381 export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
8382 if(!isWasmInitialized) {
8383 throw new Error("initializeWasm() must be awaited first!");
8385 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
8386 return nativeResponseValue;
8388 // uintptr_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
8390 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: number): number {
8391 if(!isWasmInitialized) {
8392 throw new Error("initializeWasm() must be awaited first!");
8394 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
8395 return nativeResponseValue;
8397 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
8399 export function C2Tuple_usizeTransactionZ_clone(orig: number): number {
8400 if(!isWasmInitialized) {
8401 throw new Error("initializeWasm() must be awaited first!");
8403 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
8404 return nativeResponseValue;
8406 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
8408 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): number {
8409 if(!isWasmInitialized) {
8410 throw new Error("initializeWasm() must be awaited first!");
8412 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
8413 return nativeResponseValue;
8415 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
8417 export function C2Tuple_usizeTransactionZ_free(_res: number): void {
8418 if(!isWasmInitialized) {
8419 throw new Error("initializeWasm() must be awaited first!");
8421 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
8422 // debug statements here
8424 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
8426 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8427 if(!isWasmInitialized) {
8428 throw new Error("initializeWasm() must be awaited first!");
8430 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
8431 // debug statements here
8433 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
8435 export function CVec_TxidZ_free(_res: number): void {
8436 if(!isWasmInitialized) {
8437 throw new Error("initializeWasm() must be awaited first!");
8439 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
8440 // debug statements here
8442 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
8444 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
8445 if(!isWasmInitialized) {
8446 throw new Error("initializeWasm() must be awaited first!");
8448 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
8449 return nativeResponseValue;
8451 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
8453 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): number {
8454 if(!isWasmInitialized) {
8455 throw new Error("initializeWasm() must be awaited first!");
8457 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
8458 return nativeResponseValue;
8460 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
8462 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: number): boolean {
8463 if(!isWasmInitialized) {
8464 throw new Error("initializeWasm() must be awaited first!");
8466 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
8467 return nativeResponseValue;
8469 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
8471 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
8472 if(!isWasmInitialized) {
8473 throw new Error("initializeWasm() must be awaited first!");
8475 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
8476 // debug statements here
8478 // uintptr_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
8480 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: number): number {
8481 if(!isWasmInitialized) {
8482 throw new Error("initializeWasm() must be awaited first!");
8484 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
8485 return nativeResponseValue;
8487 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
8489 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
8490 if(!isWasmInitialized) {
8491 throw new Error("initializeWasm() must be awaited first!");
8493 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
8494 return nativeResponseValue;
8496 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
8498 export function CVec_MonitorEventZ_free(_res: number): void {
8499 if(!isWasmInitialized) {
8500 throw new Error("initializeWasm() must be awaited first!");
8502 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
8503 // debug statements here
8505 // uintptr_t C2Tuple_OutPointCVec_MonitorEventZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR arg);
8507 export function C2Tuple_OutPointCVec_MonitorEventZZ_clone_ptr(arg: number): number {
8508 if(!isWasmInitialized) {
8509 throw new Error("initializeWasm() must be awaited first!");
8511 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_clone_ptr(arg);
8512 return nativeResponseValue;
8514 // struct LDKC2Tuple_OutPointCVec_MonitorEventZZ C2Tuple_OutPointCVec_MonitorEventZZ_clone(const struct LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR orig);
8516 export function C2Tuple_OutPointCVec_MonitorEventZZ_clone(orig: number): number {
8517 if(!isWasmInitialized) {
8518 throw new Error("initializeWasm() must be awaited first!");
8520 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_clone(orig);
8521 return nativeResponseValue;
8523 // struct LDKC2Tuple_OutPointCVec_MonitorEventZZ C2Tuple_OutPointCVec_MonitorEventZZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b);
8525 export function C2Tuple_OutPointCVec_MonitorEventZZ_new(a: number, b: number): number {
8526 if(!isWasmInitialized) {
8527 throw new Error("initializeWasm() must be awaited first!");
8529 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_new(a, b);
8530 return nativeResponseValue;
8532 // void C2Tuple_OutPointCVec_MonitorEventZZ_free(struct LDKC2Tuple_OutPointCVec_MonitorEventZZ _res);
8534 export function C2Tuple_OutPointCVec_MonitorEventZZ_free(_res: number): void {
8535 if(!isWasmInitialized) {
8536 throw new Error("initializeWasm() must be awaited first!");
8538 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_free(_res);
8539 // debug statements here
8541 // void CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(struct LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ _res);
8543 export function CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(_res: number): void {
8544 if(!isWasmInitialized) {
8545 throw new Error("initializeWasm() must be awaited first!");
8547 const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(_res);
8548 // debug statements here
8550 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
8552 export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
8553 if(!isWasmInitialized) {
8554 throw new Error("initializeWasm() must be awaited first!");
8556 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_some(o);
8557 return nativeResponseValue;
8559 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
8561 export function COption_C2Tuple_usizeTransactionZZ_none(): number {
8562 if(!isWasmInitialized) {
8563 throw new Error("initializeWasm() must be awaited first!");
8565 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_none();
8566 return nativeResponseValue;
8568 // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
8570 export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8571 if(!isWasmInitialized) {
8572 throw new Error("initializeWasm() must be awaited first!");
8574 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_free(_res);
8575 // debug statements here
8577 // uintptr_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
8579 export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: number): number {
8580 if(!isWasmInitialized) {
8581 throw new Error("initializeWasm() must be awaited first!");
8583 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
8584 return nativeResponseValue;
8586 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
8588 export function COption_C2Tuple_usizeTransactionZZ_clone(orig: number): number {
8589 if(!isWasmInitialized) {
8590 throw new Error("initializeWasm() must be awaited first!");
8592 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone(orig);
8593 return nativeResponseValue;
8595 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
8597 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: number): number {
8598 if(!isWasmInitialized) {
8599 throw new Error("initializeWasm() must be awaited first!");
8601 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
8602 return nativeResponseValue;
8604 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
8606 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: number): number {
8607 if(!isWasmInitialized) {
8608 throw new Error("initializeWasm() must be awaited first!");
8610 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
8611 return nativeResponseValue;
8613 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
8615 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: number): boolean {
8616 if(!isWasmInitialized) {
8617 throw new Error("initializeWasm() must be awaited first!");
8619 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
8620 return nativeResponseValue;
8622 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
8624 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: number): void {
8625 if(!isWasmInitialized) {
8626 throw new Error("initializeWasm() must be awaited first!");
8628 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
8629 // debug statements here
8631 // uintptr_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
8633 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: number): number {
8634 if(!isWasmInitialized) {
8635 throw new Error("initializeWasm() must be awaited first!");
8637 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
8638 return nativeResponseValue;
8640 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
8642 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: number): number {
8643 if(!isWasmInitialized) {
8644 throw new Error("initializeWasm() must be awaited first!");
8646 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
8647 return nativeResponseValue;
8649 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
8651 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: number): number {
8652 if(!isWasmInitialized) {
8653 throw new Error("initializeWasm() must be awaited first!");
8655 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
8656 return nativeResponseValue;
8658 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
8660 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: number): number {
8661 if(!isWasmInitialized) {
8662 throw new Error("initializeWasm() must be awaited first!");
8664 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
8665 return nativeResponseValue;
8667 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
8669 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: number): boolean {
8670 if(!isWasmInitialized) {
8671 throw new Error("initializeWasm() must be awaited first!");
8673 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
8674 return nativeResponseValue;
8676 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
8678 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: number): void {
8679 if(!isWasmInitialized) {
8680 throw new Error("initializeWasm() must be awaited first!");
8682 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
8683 // debug statements here
8685 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
8687 export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
8688 if(!isWasmInitialized) {
8689 throw new Error("initializeWasm() must be awaited first!");
8691 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
8692 return nativeResponseValue;
8694 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8696 export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
8697 if(!isWasmInitialized) {
8698 throw new Error("initializeWasm() must be awaited first!");
8700 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
8701 return nativeResponseValue;
8703 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
8705 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8706 if(!isWasmInitialized) {
8707 throw new Error("initializeWasm() must be awaited first!");
8709 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
8710 return nativeResponseValue;
8712 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
8714 export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
8715 if(!isWasmInitialized) {
8716 throw new Error("initializeWasm() must be awaited first!");
8718 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
8719 // debug statements here
8721 // uintptr_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
8723 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8724 if(!isWasmInitialized) {
8725 throw new Error("initializeWasm() must be awaited first!");
8727 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
8728 return nativeResponseValue;
8730 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
8732 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: number): number {
8733 if(!isWasmInitialized) {
8734 throw new Error("initializeWasm() must be awaited first!");
8736 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
8737 return nativeResponseValue;
8739 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
8741 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
8742 if(!isWasmInitialized) {
8743 throw new Error("initializeWasm() must be awaited first!");
8745 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
8746 return nativeResponseValue;
8748 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8750 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
8751 if(!isWasmInitialized) {
8752 throw new Error("initializeWasm() must be awaited first!");
8754 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
8755 return nativeResponseValue;
8757 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
8759 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8760 if(!isWasmInitialized) {
8761 throw new Error("initializeWasm() must be awaited first!");
8763 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
8764 return nativeResponseValue;
8766 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
8768 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
8769 if(!isWasmInitialized) {
8770 throw new Error("initializeWasm() must be awaited first!");
8772 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
8773 // debug statements here
8775 // uintptr_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
8777 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8778 if(!isWasmInitialized) {
8779 throw new Error("initializeWasm() must be awaited first!");
8781 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
8782 return nativeResponseValue;
8784 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
8786 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: number): number {
8787 if(!isWasmInitialized) {
8788 throw new Error("initializeWasm() must be awaited first!");
8790 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
8791 return nativeResponseValue;
8793 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
8795 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
8796 if(!isWasmInitialized) {
8797 throw new Error("initializeWasm() must be awaited first!");
8799 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
8800 return nativeResponseValue;
8802 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8804 export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
8805 if(!isWasmInitialized) {
8806 throw new Error("initializeWasm() must be awaited first!");
8808 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
8809 return nativeResponseValue;
8811 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
8813 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8814 if(!isWasmInitialized) {
8815 throw new Error("initializeWasm() must be awaited first!");
8817 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
8818 return nativeResponseValue;
8820 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
8822 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
8823 if(!isWasmInitialized) {
8824 throw new Error("initializeWasm() must be awaited first!");
8826 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
8827 // debug statements here
8829 // uintptr_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
8831 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8832 if(!isWasmInitialized) {
8833 throw new Error("initializeWasm() must be awaited first!");
8835 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
8836 return nativeResponseValue;
8838 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
8840 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: number): number {
8841 if(!isWasmInitialized) {
8842 throw new Error("initializeWasm() must be awaited first!");
8844 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
8845 return nativeResponseValue;
8847 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
8849 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
8850 if(!isWasmInitialized) {
8851 throw new Error("initializeWasm() must be awaited first!");
8853 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
8854 return nativeResponseValue;
8856 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8858 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
8859 if(!isWasmInitialized) {
8860 throw new Error("initializeWasm() must be awaited first!");
8862 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
8863 return nativeResponseValue;
8865 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
8867 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8868 if(!isWasmInitialized) {
8869 throw new Error("initializeWasm() must be awaited first!");
8871 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
8872 return nativeResponseValue;
8874 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
8876 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
8877 if(!isWasmInitialized) {
8878 throw new Error("initializeWasm() must be awaited first!");
8880 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
8881 // debug statements here
8883 // uintptr_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
8885 export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8886 if(!isWasmInitialized) {
8887 throw new Error("initializeWasm() must be awaited first!");
8889 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
8890 return nativeResponseValue;
8892 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
8894 export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: number): number {
8895 if(!isWasmInitialized) {
8896 throw new Error("initializeWasm() must be awaited first!");
8898 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
8899 return nativeResponseValue;
8901 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
8903 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: number): number {
8904 if(!isWasmInitialized) {
8905 throw new Error("initializeWasm() must be awaited first!");
8907 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
8908 return nativeResponseValue;
8910 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8912 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: number): number {
8913 if(!isWasmInitialized) {
8914 throw new Error("initializeWasm() must be awaited first!");
8916 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
8917 return nativeResponseValue;
8919 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
8921 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8922 if(!isWasmInitialized) {
8923 throw new Error("initializeWasm() must be awaited first!");
8925 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
8926 return nativeResponseValue;
8928 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
8930 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: number): void {
8931 if(!isWasmInitialized) {
8932 throw new Error("initializeWasm() must be awaited first!");
8934 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
8935 // debug statements here
8937 // uintptr_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
8939 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8940 if(!isWasmInitialized) {
8941 throw new Error("initializeWasm() must be awaited first!");
8943 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
8944 return nativeResponseValue;
8946 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
8948 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: number): number {
8949 if(!isWasmInitialized) {
8950 throw new Error("initializeWasm() must be awaited first!");
8952 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
8953 return nativeResponseValue;
8955 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
8957 export function CResult_NodeIdDecodeErrorZ_ok(o: number): number {
8958 if(!isWasmInitialized) {
8959 throw new Error("initializeWasm() must be awaited first!");
8961 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
8962 return nativeResponseValue;
8964 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
8966 export function CResult_NodeIdDecodeErrorZ_err(e: number): number {
8967 if(!isWasmInitialized) {
8968 throw new Error("initializeWasm() must be awaited first!");
8970 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
8971 return nativeResponseValue;
8973 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
8975 export function CResult_NodeIdDecodeErrorZ_is_ok(o: number): boolean {
8976 if(!isWasmInitialized) {
8977 throw new Error("initializeWasm() must be awaited first!");
8979 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
8980 return nativeResponseValue;
8982 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
8984 export function CResult_NodeIdDecodeErrorZ_free(_res: number): void {
8985 if(!isWasmInitialized) {
8986 throw new Error("initializeWasm() must be awaited first!");
8988 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
8989 // debug statements here
8991 // uintptr_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
8993 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: number): number {
8994 if(!isWasmInitialized) {
8995 throw new Error("initializeWasm() must be awaited first!");
8997 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
8998 return nativeResponseValue;
9000 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
9002 export function CResult_NodeIdDecodeErrorZ_clone(orig: number): number {
9003 if(!isWasmInitialized) {
9004 throw new Error("initializeWasm() must be awaited first!");
9006 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
9007 return nativeResponseValue;
9009 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
9011 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: number): number {
9012 if(!isWasmInitialized) {
9013 throw new Error("initializeWasm() must be awaited first!");
9015 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
9016 return nativeResponseValue;
9018 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
9020 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: number): number {
9021 if(!isWasmInitialized) {
9022 throw new Error("initializeWasm() must be awaited first!");
9024 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
9025 return nativeResponseValue;
9027 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
9029 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: number): boolean {
9030 if(!isWasmInitialized) {
9031 throw new Error("initializeWasm() must be awaited first!");
9033 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
9034 return nativeResponseValue;
9036 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
9038 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: number): void {
9039 if(!isWasmInitialized) {
9040 throw new Error("initializeWasm() must be awaited first!");
9042 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
9043 // debug statements here
9045 // uintptr_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
9047 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: number): number {
9048 if(!isWasmInitialized) {
9049 throw new Error("initializeWasm() must be awaited first!");
9051 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
9052 return nativeResponseValue;
9054 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
9056 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: number): number {
9057 if(!isWasmInitialized) {
9058 throw new Error("initializeWasm() must be awaited first!");
9060 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
9061 return nativeResponseValue;
9063 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
9065 export function COption_AccessZ_some(o: number): number {
9066 if(!isWasmInitialized) {
9067 throw new Error("initializeWasm() must be awaited first!");
9069 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
9070 return nativeResponseValue;
9072 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
9074 export function COption_AccessZ_none(): number {
9075 if(!isWasmInitialized) {
9076 throw new Error("initializeWasm() must be awaited first!");
9078 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
9079 return nativeResponseValue;
9081 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
9083 export function COption_AccessZ_free(_res: number): void {
9084 if(!isWasmInitialized) {
9085 throw new Error("initializeWasm() must be awaited first!");
9087 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
9088 // debug statements here
9090 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
9092 export function CResult_boolLightningErrorZ_ok(o: boolean): number {
9093 if(!isWasmInitialized) {
9094 throw new Error("initializeWasm() must be awaited first!");
9096 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
9097 return nativeResponseValue;
9099 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
9101 export function CResult_boolLightningErrorZ_err(e: number): number {
9102 if(!isWasmInitialized) {
9103 throw new Error("initializeWasm() must be awaited first!");
9105 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
9106 return nativeResponseValue;
9108 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
9110 export function CResult_boolLightningErrorZ_is_ok(o: number): boolean {
9111 if(!isWasmInitialized) {
9112 throw new Error("initializeWasm() must be awaited first!");
9114 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
9115 return nativeResponseValue;
9117 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
9119 export function CResult_boolLightningErrorZ_free(_res: number): void {
9120 if(!isWasmInitialized) {
9121 throw new Error("initializeWasm() must be awaited first!");
9123 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
9124 // debug statements here
9126 // uintptr_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
9128 export function CResult_boolLightningErrorZ_clone_ptr(arg: number): number {
9129 if(!isWasmInitialized) {
9130 throw new Error("initializeWasm() must be awaited first!");
9132 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
9133 return nativeResponseValue;
9135 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
9137 export function CResult_boolLightningErrorZ_clone(orig: number): number {
9138 if(!isWasmInitialized) {
9139 throw new Error("initializeWasm() must be awaited first!");
9141 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
9142 return nativeResponseValue;
9144 // uintptr_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
9146 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: number): number {
9147 if(!isWasmInitialized) {
9148 throw new Error("initializeWasm() must be awaited first!");
9150 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
9151 return nativeResponseValue;
9153 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
9155 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
9156 if(!isWasmInitialized) {
9157 throw new Error("initializeWasm() must be awaited first!");
9159 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
9160 return nativeResponseValue;
9162 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
9164 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
9165 if(!isWasmInitialized) {
9166 throw new Error("initializeWasm() must be awaited first!");
9168 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
9169 return nativeResponseValue;
9171 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
9173 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
9174 if(!isWasmInitialized) {
9175 throw new Error("initializeWasm() must be awaited first!");
9177 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
9178 // debug statements here
9180 // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
9182 export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number): void {
9183 if(!isWasmInitialized) {
9184 throw new Error("initializeWasm() must be awaited first!");
9186 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
9187 // debug statements here
9189 // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
9191 export function CVec_NodeAnnouncementZ_free(_res: number): void {
9192 if(!isWasmInitialized) {
9193 throw new Error("initializeWasm() must be awaited first!");
9195 const nativeResponseValue = wasm.TS_CVec_NodeAnnouncementZ_free(_res);
9196 // debug statements here
9198 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
9200 export function CResult_NoneLightningErrorZ_ok(): number {
9201 if(!isWasmInitialized) {
9202 throw new Error("initializeWasm() must be awaited first!");
9204 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
9205 return nativeResponseValue;
9207 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
9209 export function CResult_NoneLightningErrorZ_err(e: number): number {
9210 if(!isWasmInitialized) {
9211 throw new Error("initializeWasm() must be awaited first!");
9213 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
9214 return nativeResponseValue;
9216 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
9218 export function CResult_NoneLightningErrorZ_is_ok(o: number): boolean {
9219 if(!isWasmInitialized) {
9220 throw new Error("initializeWasm() must be awaited first!");
9222 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
9223 return nativeResponseValue;
9225 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
9227 export function CResult_NoneLightningErrorZ_free(_res: number): void {
9228 if(!isWasmInitialized) {
9229 throw new Error("initializeWasm() must be awaited first!");
9231 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
9232 // debug statements here
9234 // uintptr_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
9236 export function CResult_NoneLightningErrorZ_clone_ptr(arg: number): number {
9237 if(!isWasmInitialized) {
9238 throw new Error("initializeWasm() must be awaited first!");
9240 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
9241 return nativeResponseValue;
9243 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
9245 export function CResult_NoneLightningErrorZ_clone(orig: number): number {
9246 if(!isWasmInitialized) {
9247 throw new Error("initializeWasm() must be awaited first!");
9249 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
9250 return nativeResponseValue;
9252 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
9254 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: number): number {
9255 if(!isWasmInitialized) {
9256 throw new Error("initializeWasm() must be awaited first!");
9258 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
9259 return nativeResponseValue;
9261 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
9263 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: number): number {
9264 if(!isWasmInitialized) {
9265 throw new Error("initializeWasm() must be awaited first!");
9267 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
9268 return nativeResponseValue;
9270 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
9272 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: number): boolean {
9273 if(!isWasmInitialized) {
9274 throw new Error("initializeWasm() must be awaited first!");
9276 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
9277 return nativeResponseValue;
9279 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
9281 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: number): void {
9282 if(!isWasmInitialized) {
9283 throw new Error("initializeWasm() must be awaited first!");
9285 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
9286 // debug statements here
9288 // uintptr_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
9290 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: number): number {
9291 if(!isWasmInitialized) {
9292 throw new Error("initializeWasm() must be awaited first!");
9294 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
9295 return nativeResponseValue;
9297 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
9299 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: number): number {
9300 if(!isWasmInitialized) {
9301 throw new Error("initializeWasm() must be awaited first!");
9303 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
9304 return nativeResponseValue;
9306 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
9308 export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
9309 if(!isWasmInitialized) {
9310 throw new Error("initializeWasm() must be awaited first!");
9312 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
9313 return nativeResponseValue;
9315 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
9317 export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
9318 if(!isWasmInitialized) {
9319 throw new Error("initializeWasm() must be awaited first!");
9321 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
9322 return nativeResponseValue;
9324 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
9326 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
9327 if(!isWasmInitialized) {
9328 throw new Error("initializeWasm() must be awaited first!");
9330 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
9331 return nativeResponseValue;
9333 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
9335 export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
9336 if(!isWasmInitialized) {
9337 throw new Error("initializeWasm() must be awaited first!");
9339 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
9340 // debug statements here
9342 // uintptr_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
9344 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
9345 if(!isWasmInitialized) {
9346 throw new Error("initializeWasm() must be awaited first!");
9348 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
9349 return nativeResponseValue;
9351 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
9353 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
9354 if(!isWasmInitialized) {
9355 throw new Error("initializeWasm() must be awaited first!");
9357 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
9358 return nativeResponseValue;
9360 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
9362 export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
9363 if(!isWasmInitialized) {
9364 throw new Error("initializeWasm() must be awaited first!");
9366 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
9367 return nativeResponseValue;
9369 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
9371 export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
9372 if(!isWasmInitialized) {
9373 throw new Error("initializeWasm() must be awaited first!");
9375 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
9376 return nativeResponseValue;
9378 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
9380 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: number): boolean {
9381 if(!isWasmInitialized) {
9382 throw new Error("initializeWasm() must be awaited first!");
9384 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
9385 return nativeResponseValue;
9387 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
9389 export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
9390 if(!isWasmInitialized) {
9391 throw new Error("initializeWasm() must be awaited first!");
9393 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
9394 // debug statements here
9396 // uintptr_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
9398 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: number): number {
9399 if(!isWasmInitialized) {
9400 throw new Error("initializeWasm() must be awaited first!");
9402 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
9403 return nativeResponseValue;
9405 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
9407 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
9408 if(!isWasmInitialized) {
9409 throw new Error("initializeWasm() must be awaited first!");
9411 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
9412 return nativeResponseValue;
9414 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
9416 export function CVec_NetAddressZ_free(_res: number): void {
9417 if(!isWasmInitialized) {
9418 throw new Error("initializeWasm() must be awaited first!");
9420 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
9421 // debug statements here
9423 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
9425 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
9426 if(!isWasmInitialized) {
9427 throw new Error("initializeWasm() must be awaited first!");
9429 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
9430 return nativeResponseValue;
9432 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
9434 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
9435 if(!isWasmInitialized) {
9436 throw new Error("initializeWasm() must be awaited first!");
9438 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
9439 return nativeResponseValue;
9441 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
9443 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: number): boolean {
9444 if(!isWasmInitialized) {
9445 throw new Error("initializeWasm() must be awaited first!");
9447 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
9448 return nativeResponseValue;
9450 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
9452 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
9453 if(!isWasmInitialized) {
9454 throw new Error("initializeWasm() must be awaited first!");
9456 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
9457 // debug statements here
9459 // uintptr_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
9461 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: number): number {
9462 if(!isWasmInitialized) {
9463 throw new Error("initializeWasm() must be awaited first!");
9465 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
9466 return nativeResponseValue;
9468 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
9470 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
9471 if(!isWasmInitialized) {
9472 throw new Error("initializeWasm() must be awaited first!");
9474 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
9475 return nativeResponseValue;
9477 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
9479 export function CVec_u64Z_free(_res: number): void {
9480 if(!isWasmInitialized) {
9481 throw new Error("initializeWasm() must be awaited first!");
9483 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
9484 // debug statements here
9486 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
9488 export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
9489 if(!isWasmInitialized) {
9490 throw new Error("initializeWasm() must be awaited first!");
9492 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
9493 return nativeResponseValue;
9495 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
9497 export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
9498 if(!isWasmInitialized) {
9499 throw new Error("initializeWasm() must be awaited first!");
9501 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
9502 return nativeResponseValue;
9504 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
9506 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: number): boolean {
9507 if(!isWasmInitialized) {
9508 throw new Error("initializeWasm() must be awaited first!");
9510 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
9511 return nativeResponseValue;
9513 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
9515 export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
9516 if(!isWasmInitialized) {
9517 throw new Error("initializeWasm() must be awaited first!");
9519 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
9520 // debug statements here
9522 // uintptr_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
9524 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: number): number {
9525 if(!isWasmInitialized) {
9526 throw new Error("initializeWasm() must be awaited first!");
9528 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
9529 return nativeResponseValue;
9531 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
9533 export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
9534 if(!isWasmInitialized) {
9535 throw new Error("initializeWasm() must be awaited first!");
9537 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
9538 return nativeResponseValue;
9540 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
9542 export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
9543 if(!isWasmInitialized) {
9544 throw new Error("initializeWasm() must be awaited first!");
9546 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
9547 return nativeResponseValue;
9549 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
9551 export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
9552 if(!isWasmInitialized) {
9553 throw new Error("initializeWasm() must be awaited first!");
9555 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
9556 return nativeResponseValue;
9558 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
9560 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: number): boolean {
9561 if(!isWasmInitialized) {
9562 throw new Error("initializeWasm() must be awaited first!");
9564 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
9565 return nativeResponseValue;
9567 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
9569 export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
9570 if(!isWasmInitialized) {
9571 throw new Error("initializeWasm() must be awaited first!");
9573 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
9574 // debug statements here
9576 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
9578 export function COption_CVec_NetAddressZZ_some(o: number): number {
9579 if(!isWasmInitialized) {
9580 throw new Error("initializeWasm() must be awaited first!");
9582 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
9583 return nativeResponseValue;
9585 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
9587 export function COption_CVec_NetAddressZZ_none(): number {
9588 if(!isWasmInitialized) {
9589 throw new Error("initializeWasm() must be awaited first!");
9591 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
9592 return nativeResponseValue;
9594 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
9596 export function COption_CVec_NetAddressZZ_free(_res: number): void {
9597 if(!isWasmInitialized) {
9598 throw new Error("initializeWasm() must be awaited first!");
9600 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
9601 // debug statements here
9603 // uintptr_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
9605 export function COption_CVec_NetAddressZZ_clone_ptr(arg: number): number {
9606 if(!isWasmInitialized) {
9607 throw new Error("initializeWasm() must be awaited first!");
9609 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
9610 return nativeResponseValue;
9612 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
9614 export function COption_CVec_NetAddressZZ_clone(orig: number): number {
9615 if(!isWasmInitialized) {
9616 throw new Error("initializeWasm() must be awaited first!");
9618 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
9619 return nativeResponseValue;
9621 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
9623 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
9624 if(!isWasmInitialized) {
9625 throw new Error("initializeWasm() must be awaited first!");
9627 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
9628 return nativeResponseValue;
9630 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
9632 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
9633 if(!isWasmInitialized) {
9634 throw new Error("initializeWasm() must be awaited first!");
9636 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
9637 return nativeResponseValue;
9639 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
9641 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
9642 if(!isWasmInitialized) {
9643 throw new Error("initializeWasm() must be awaited first!");
9645 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
9646 return nativeResponseValue;
9648 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
9650 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
9651 if(!isWasmInitialized) {
9652 throw new Error("initializeWasm() must be awaited first!");
9654 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
9655 // debug statements here
9657 // uintptr_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
9659 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
9660 if(!isWasmInitialized) {
9661 throw new Error("initializeWasm() must be awaited first!");
9663 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
9664 return nativeResponseValue;
9666 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
9668 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
9669 if(!isWasmInitialized) {
9670 throw new Error("initializeWasm() must be awaited first!");
9672 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
9673 return nativeResponseValue;
9675 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
9677 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
9678 if(!isWasmInitialized) {
9679 throw new Error("initializeWasm() must be awaited first!");
9681 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
9682 return nativeResponseValue;
9684 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
9686 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
9687 if(!isWasmInitialized) {
9688 throw new Error("initializeWasm() must be awaited first!");
9690 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
9691 return nativeResponseValue;
9693 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
9695 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
9696 if(!isWasmInitialized) {
9697 throw new Error("initializeWasm() must be awaited first!");
9699 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
9700 return nativeResponseValue;
9702 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
9704 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
9705 if(!isWasmInitialized) {
9706 throw new Error("initializeWasm() must be awaited first!");
9708 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
9709 // debug statements here
9711 // uintptr_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
9713 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
9714 if(!isWasmInitialized) {
9715 throw new Error("initializeWasm() must be awaited first!");
9717 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
9718 return nativeResponseValue;
9720 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
9722 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
9723 if(!isWasmInitialized) {
9724 throw new Error("initializeWasm() must be awaited first!");
9726 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
9727 return nativeResponseValue;
9729 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
9731 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
9732 if(!isWasmInitialized) {
9733 throw new Error("initializeWasm() must be awaited first!");
9735 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
9736 return nativeResponseValue;
9738 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
9740 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
9741 if(!isWasmInitialized) {
9742 throw new Error("initializeWasm() must be awaited first!");
9744 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
9745 return nativeResponseValue;
9747 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
9749 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
9750 if(!isWasmInitialized) {
9751 throw new Error("initializeWasm() must be awaited first!");
9753 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
9754 return nativeResponseValue;
9756 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
9758 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
9759 if(!isWasmInitialized) {
9760 throw new Error("initializeWasm() must be awaited first!");
9762 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
9763 // debug statements here
9765 // uintptr_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
9767 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
9768 if(!isWasmInitialized) {
9769 throw new Error("initializeWasm() must be awaited first!");
9771 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
9772 return nativeResponseValue;
9774 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
9776 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
9777 if(!isWasmInitialized) {
9778 throw new Error("initializeWasm() must be awaited first!");
9780 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
9781 return nativeResponseValue;
9783 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
9785 export function CVec_PaymentPreimageZ_free(_res: number): void {
9786 if(!isWasmInitialized) {
9787 throw new Error("initializeWasm() must be awaited first!");
9789 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
9790 // debug statements here
9792 // uintptr_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
9794 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: number): number {
9795 if(!isWasmInitialized) {
9796 throw new Error("initializeWasm() must be awaited first!");
9798 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
9799 return nativeResponseValue;
9801 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
9803 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
9804 if(!isWasmInitialized) {
9805 throw new Error("initializeWasm() must be awaited first!");
9807 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
9808 return nativeResponseValue;
9810 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
9812 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): number {
9813 if(!isWasmInitialized) {
9814 throw new Error("initializeWasm() must be awaited first!");
9816 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
9817 return nativeResponseValue;
9819 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
9821 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
9822 if(!isWasmInitialized) {
9823 throw new Error("initializeWasm() must be awaited first!");
9825 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
9826 // debug statements here
9828 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
9830 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
9831 if(!isWasmInitialized) {
9832 throw new Error("initializeWasm() must be awaited first!");
9834 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
9835 return nativeResponseValue;
9837 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
9839 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
9840 if(!isWasmInitialized) {
9841 throw new Error("initializeWasm() must be awaited first!");
9843 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
9844 return nativeResponseValue;
9846 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
9848 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: number): boolean {
9849 if(!isWasmInitialized) {
9850 throw new Error("initializeWasm() must be awaited first!");
9852 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
9853 return nativeResponseValue;
9855 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
9857 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
9858 if(!isWasmInitialized) {
9859 throw new Error("initializeWasm() must be awaited first!");
9861 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
9862 // debug statements here
9864 // uintptr_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
9866 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: number): number {
9867 if(!isWasmInitialized) {
9868 throw new Error("initializeWasm() must be awaited first!");
9870 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
9871 return nativeResponseValue;
9873 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
9875 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
9876 if(!isWasmInitialized) {
9877 throw new Error("initializeWasm() must be awaited first!");
9879 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
9880 return nativeResponseValue;
9882 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
9884 export function CResult_SignatureNoneZ_ok(o: number): number {
9885 if(!isWasmInitialized) {
9886 throw new Error("initializeWasm() must be awaited first!");
9888 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
9889 return nativeResponseValue;
9891 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
9893 export function CResult_SignatureNoneZ_err(): number {
9894 if(!isWasmInitialized) {
9895 throw new Error("initializeWasm() must be awaited first!");
9897 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
9898 return nativeResponseValue;
9900 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
9902 export function CResult_SignatureNoneZ_is_ok(o: number): boolean {
9903 if(!isWasmInitialized) {
9904 throw new Error("initializeWasm() must be awaited first!");
9906 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
9907 return nativeResponseValue;
9909 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
9911 export function CResult_SignatureNoneZ_free(_res: number): void {
9912 if(!isWasmInitialized) {
9913 throw new Error("initializeWasm() must be awaited first!");
9915 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
9916 // debug statements here
9918 // uintptr_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
9920 export function CResult_SignatureNoneZ_clone_ptr(arg: number): number {
9921 if(!isWasmInitialized) {
9922 throw new Error("initializeWasm() must be awaited first!");
9924 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
9925 return nativeResponseValue;
9927 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
9929 export function CResult_SignatureNoneZ_clone(orig: number): number {
9930 if(!isWasmInitialized) {
9931 throw new Error("initializeWasm() must be awaited first!");
9933 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
9934 return nativeResponseValue;
9936 // uintptr_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
9938 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: number): number {
9939 if(!isWasmInitialized) {
9940 throw new Error("initializeWasm() must be awaited first!");
9942 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
9943 return nativeResponseValue;
9945 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
9947 export function C2Tuple_SignatureSignatureZ_clone(orig: number): number {
9948 if(!isWasmInitialized) {
9949 throw new Error("initializeWasm() must be awaited first!");
9951 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
9952 return nativeResponseValue;
9954 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
9956 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): number {
9957 if(!isWasmInitialized) {
9958 throw new Error("initializeWasm() must be awaited first!");
9960 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
9961 return nativeResponseValue;
9963 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
9965 export function C2Tuple_SignatureSignatureZ_free(_res: number): void {
9966 if(!isWasmInitialized) {
9967 throw new Error("initializeWasm() must be awaited first!");
9969 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
9970 // debug statements here
9972 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
9974 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: number): number {
9975 if(!isWasmInitialized) {
9976 throw new Error("initializeWasm() must be awaited first!");
9978 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
9979 return nativeResponseValue;
9981 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
9983 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): number {
9984 if(!isWasmInitialized) {
9985 throw new Error("initializeWasm() must be awaited first!");
9987 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
9988 return nativeResponseValue;
9990 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
9992 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: number): boolean {
9993 if(!isWasmInitialized) {
9994 throw new Error("initializeWasm() must be awaited first!");
9996 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
9997 return nativeResponseValue;
9999 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
10001 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: number): void {
10002 if(!isWasmInitialized) {
10003 throw new Error("initializeWasm() must be awaited first!");
10005 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
10006 // debug statements here
10008 // uintptr_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
10010 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: number): number {
10011 if(!isWasmInitialized) {
10012 throw new Error("initializeWasm() must be awaited first!");
10014 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
10015 return nativeResponseValue;
10017 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
10019 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: number): number {
10020 if(!isWasmInitialized) {
10021 throw new Error("initializeWasm() must be awaited first!");
10023 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
10024 return nativeResponseValue;
10026 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
10028 export function CResult_SecretKeyNoneZ_ok(o: number): number {
10029 if(!isWasmInitialized) {
10030 throw new Error("initializeWasm() must be awaited first!");
10032 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
10033 return nativeResponseValue;
10035 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
10037 export function CResult_SecretKeyNoneZ_err(): number {
10038 if(!isWasmInitialized) {
10039 throw new Error("initializeWasm() must be awaited first!");
10041 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
10042 return nativeResponseValue;
10044 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
10046 export function CResult_SecretKeyNoneZ_is_ok(o: number): boolean {
10047 if(!isWasmInitialized) {
10048 throw new Error("initializeWasm() must be awaited first!");
10050 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
10051 return nativeResponseValue;
10053 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
10055 export function CResult_SecretKeyNoneZ_free(_res: number): void {
10056 if(!isWasmInitialized) {
10057 throw new Error("initializeWasm() must be awaited first!");
10059 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
10060 // debug statements here
10062 // uintptr_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
10064 export function CResult_SecretKeyNoneZ_clone_ptr(arg: number): number {
10065 if(!isWasmInitialized) {
10066 throw new Error("initializeWasm() must be awaited first!");
10068 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
10069 return nativeResponseValue;
10071 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
10073 export function CResult_SecretKeyNoneZ_clone(orig: number): number {
10074 if(!isWasmInitialized) {
10075 throw new Error("initializeWasm() must be awaited first!");
10077 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
10078 return nativeResponseValue;
10080 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
10082 export function CResult_SignDecodeErrorZ_ok(o: number): number {
10083 if(!isWasmInitialized) {
10084 throw new Error("initializeWasm() must be awaited first!");
10086 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
10087 return nativeResponseValue;
10089 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
10091 export function CResult_SignDecodeErrorZ_err(e: number): number {
10092 if(!isWasmInitialized) {
10093 throw new Error("initializeWasm() must be awaited first!");
10095 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
10096 return nativeResponseValue;
10098 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
10100 export function CResult_SignDecodeErrorZ_is_ok(o: number): boolean {
10101 if(!isWasmInitialized) {
10102 throw new Error("initializeWasm() must be awaited first!");
10104 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
10105 return nativeResponseValue;
10107 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
10109 export function CResult_SignDecodeErrorZ_free(_res: number): void {
10110 if(!isWasmInitialized) {
10111 throw new Error("initializeWasm() must be awaited first!");
10113 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
10114 // debug statements here
10116 // uintptr_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
10118 export function CResult_SignDecodeErrorZ_clone_ptr(arg: number): number {
10119 if(!isWasmInitialized) {
10120 throw new Error("initializeWasm() must be awaited first!");
10122 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
10123 return nativeResponseValue;
10125 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
10127 export function CResult_SignDecodeErrorZ_clone(orig: number): number {
10128 if(!isWasmInitialized) {
10129 throw new Error("initializeWasm() must be awaited first!");
10131 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
10132 return nativeResponseValue;
10134 // void CVec_u5Z_free(struct LDKCVec_u5Z _res);
10136 export function CVec_u5Z_free(_res: number): void {
10137 if(!isWasmInitialized) {
10138 throw new Error("initializeWasm() must be awaited first!");
10140 const nativeResponseValue = wasm.TS_CVec_u5Z_free(_res);
10141 // debug statements here
10143 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
10145 export function CResult_RecoverableSignatureNoneZ_ok(o: number): number {
10146 if(!isWasmInitialized) {
10147 throw new Error("initializeWasm() must be awaited first!");
10149 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
10150 return nativeResponseValue;
10152 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
10154 export function CResult_RecoverableSignatureNoneZ_err(): number {
10155 if(!isWasmInitialized) {
10156 throw new Error("initializeWasm() must be awaited first!");
10158 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
10159 return nativeResponseValue;
10161 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
10163 export function CResult_RecoverableSignatureNoneZ_is_ok(o: number): boolean {
10164 if(!isWasmInitialized) {
10165 throw new Error("initializeWasm() must be awaited first!");
10167 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
10168 return nativeResponseValue;
10170 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
10172 export function CResult_RecoverableSignatureNoneZ_free(_res: number): void {
10173 if(!isWasmInitialized) {
10174 throw new Error("initializeWasm() must be awaited first!");
10176 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
10177 // debug statements here
10179 // uintptr_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
10181 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: number): number {
10182 if(!isWasmInitialized) {
10183 throw new Error("initializeWasm() must be awaited first!");
10185 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
10186 return nativeResponseValue;
10188 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
10190 export function CResult_RecoverableSignatureNoneZ_clone(orig: number): number {
10191 if(!isWasmInitialized) {
10192 throw new Error("initializeWasm() must be awaited first!");
10194 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
10195 return nativeResponseValue;
10197 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
10199 export function CVec_u8Z_free(_res: number): void {
10200 if(!isWasmInitialized) {
10201 throw new Error("initializeWasm() must be awaited first!");
10203 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
10204 // debug statements here
10206 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
10208 export function CVec_CVec_u8ZZ_free(_res: number): void {
10209 if(!isWasmInitialized) {
10210 throw new Error("initializeWasm() must be awaited first!");
10212 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
10213 // debug statements here
10215 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
10217 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): number {
10218 if(!isWasmInitialized) {
10219 throw new Error("initializeWasm() must be awaited first!");
10221 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
10222 return nativeResponseValue;
10224 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
10226 export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
10227 if(!isWasmInitialized) {
10228 throw new Error("initializeWasm() must be awaited first!");
10230 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
10231 return nativeResponseValue;
10233 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
10235 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: number): boolean {
10236 if(!isWasmInitialized) {
10237 throw new Error("initializeWasm() must be awaited first!");
10239 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
10240 return nativeResponseValue;
10242 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
10244 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
10245 if(!isWasmInitialized) {
10246 throw new Error("initializeWasm() must be awaited first!");
10248 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
10249 // debug statements here
10251 // uintptr_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
10253 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: number): number {
10254 if(!isWasmInitialized) {
10255 throw new Error("initializeWasm() must be awaited first!");
10257 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
10258 return nativeResponseValue;
10260 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
10262 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
10263 if(!isWasmInitialized) {
10264 throw new Error("initializeWasm() must be awaited first!");
10266 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
10267 return nativeResponseValue;
10269 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
10271 export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
10272 if(!isWasmInitialized) {
10273 throw new Error("initializeWasm() must be awaited first!");
10275 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
10276 return nativeResponseValue;
10278 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
10280 export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
10281 if(!isWasmInitialized) {
10282 throw new Error("initializeWasm() must be awaited first!");
10284 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
10285 return nativeResponseValue;
10287 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
10289 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: number): boolean {
10290 if(!isWasmInitialized) {
10291 throw new Error("initializeWasm() must be awaited first!");
10293 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
10294 return nativeResponseValue;
10296 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
10298 export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
10299 if(!isWasmInitialized) {
10300 throw new Error("initializeWasm() must be awaited first!");
10302 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
10303 // debug statements here
10305 // uintptr_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
10307 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: number): number {
10308 if(!isWasmInitialized) {
10309 throw new Error("initializeWasm() must be awaited first!");
10311 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
10312 return nativeResponseValue;
10314 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
10316 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
10317 if(!isWasmInitialized) {
10318 throw new Error("initializeWasm() must be awaited first!");
10320 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
10321 return nativeResponseValue;
10323 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
10325 export function CVec_TxOutZ_free(_res: number): void {
10326 if(!isWasmInitialized) {
10327 throw new Error("initializeWasm() must be awaited first!");
10329 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
10330 // debug statements here
10332 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
10334 export function CResult_TransactionNoneZ_ok(o: number): number {
10335 if(!isWasmInitialized) {
10336 throw new Error("initializeWasm() must be awaited first!");
10338 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
10339 return nativeResponseValue;
10341 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
10343 export function CResult_TransactionNoneZ_err(): number {
10344 if(!isWasmInitialized) {
10345 throw new Error("initializeWasm() must be awaited first!");
10347 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
10348 return nativeResponseValue;
10350 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
10352 export function CResult_TransactionNoneZ_is_ok(o: number): boolean {
10353 if(!isWasmInitialized) {
10354 throw new Error("initializeWasm() must be awaited first!");
10356 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
10357 return nativeResponseValue;
10359 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
10361 export function CResult_TransactionNoneZ_free(_res: number): void {
10362 if(!isWasmInitialized) {
10363 throw new Error("initializeWasm() must be awaited first!");
10365 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
10366 // debug statements here
10368 // uintptr_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
10370 export function CResult_TransactionNoneZ_clone_ptr(arg: number): number {
10371 if(!isWasmInitialized) {
10372 throw new Error("initializeWasm() must be awaited first!");
10374 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
10375 return nativeResponseValue;
10377 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
10379 export function CResult_TransactionNoneZ_clone(orig: number): number {
10380 if(!isWasmInitialized) {
10381 throw new Error("initializeWasm() must be awaited first!");
10383 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
10384 return nativeResponseValue;
10386 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
10388 export function COption_u16Z_some(o: number): number {
10389 if(!isWasmInitialized) {
10390 throw new Error("initializeWasm() must be awaited first!");
10392 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
10393 return nativeResponseValue;
10395 // struct LDKCOption_u16Z COption_u16Z_none(void);
10397 export function COption_u16Z_none(): number {
10398 if(!isWasmInitialized) {
10399 throw new Error("initializeWasm() must be awaited first!");
10401 const nativeResponseValue = wasm.TS_COption_u16Z_none();
10402 return nativeResponseValue;
10404 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
10406 export function COption_u16Z_free(_res: number): void {
10407 if(!isWasmInitialized) {
10408 throw new Error("initializeWasm() must be awaited first!");
10410 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
10411 // debug statements here
10413 // uintptr_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
10415 export function COption_u16Z_clone_ptr(arg: number): number {
10416 if(!isWasmInitialized) {
10417 throw new Error("initializeWasm() must be awaited first!");
10419 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
10420 return nativeResponseValue;
10422 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
10424 export function COption_u16Z_clone(orig: number): number {
10425 if(!isWasmInitialized) {
10426 throw new Error("initializeWasm() must be awaited first!");
10428 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
10429 return nativeResponseValue;
10431 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
10433 export function CResult_NoneAPIErrorZ_ok(): number {
10434 if(!isWasmInitialized) {
10435 throw new Error("initializeWasm() must be awaited first!");
10437 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
10438 return nativeResponseValue;
10440 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
10442 export function CResult_NoneAPIErrorZ_err(e: number): number {
10443 if(!isWasmInitialized) {
10444 throw new Error("initializeWasm() must be awaited first!");
10446 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
10447 return nativeResponseValue;
10449 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
10451 export function CResult_NoneAPIErrorZ_is_ok(o: number): boolean {
10452 if(!isWasmInitialized) {
10453 throw new Error("initializeWasm() must be awaited first!");
10455 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
10456 return nativeResponseValue;
10458 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
10460 export function CResult_NoneAPIErrorZ_free(_res: number): void {
10461 if(!isWasmInitialized) {
10462 throw new Error("initializeWasm() must be awaited first!");
10464 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
10465 // debug statements here
10467 // uintptr_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
10469 export function CResult_NoneAPIErrorZ_clone_ptr(arg: number): number {
10470 if(!isWasmInitialized) {
10471 throw new Error("initializeWasm() must be awaited first!");
10473 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
10474 return nativeResponseValue;
10476 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
10478 export function CResult_NoneAPIErrorZ_clone(orig: number): number {
10479 if(!isWasmInitialized) {
10480 throw new Error("initializeWasm() must be awaited first!");
10482 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
10483 return nativeResponseValue;
10485 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
10487 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
10488 if(!isWasmInitialized) {
10489 throw new Error("initializeWasm() must be awaited first!");
10491 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
10492 // debug statements here
10494 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
10496 export function CVec_APIErrorZ_free(_res: number): void {
10497 if(!isWasmInitialized) {
10498 throw new Error("initializeWasm() must be awaited first!");
10500 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
10501 // debug statements here
10503 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
10505 export function CResult__u832APIErrorZ_ok(o: number): number {
10506 if(!isWasmInitialized) {
10507 throw new Error("initializeWasm() must be awaited first!");
10509 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
10510 return nativeResponseValue;
10512 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
10514 export function CResult__u832APIErrorZ_err(e: number): number {
10515 if(!isWasmInitialized) {
10516 throw new Error("initializeWasm() must be awaited first!");
10518 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
10519 return nativeResponseValue;
10521 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
10523 export function CResult__u832APIErrorZ_is_ok(o: number): boolean {
10524 if(!isWasmInitialized) {
10525 throw new Error("initializeWasm() must be awaited first!");
10527 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
10528 return nativeResponseValue;
10530 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
10532 export function CResult__u832APIErrorZ_free(_res: number): void {
10533 if(!isWasmInitialized) {
10534 throw new Error("initializeWasm() must be awaited first!");
10536 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
10537 // debug statements here
10539 // uintptr_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
10541 export function CResult__u832APIErrorZ_clone_ptr(arg: number): number {
10542 if(!isWasmInitialized) {
10543 throw new Error("initializeWasm() must be awaited first!");
10545 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
10546 return nativeResponseValue;
10548 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
10550 export function CResult__u832APIErrorZ_clone(orig: number): number {
10551 if(!isWasmInitialized) {
10552 throw new Error("initializeWasm() must be awaited first!");
10554 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
10555 return nativeResponseValue;
10557 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
10559 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): number {
10560 if(!isWasmInitialized) {
10561 throw new Error("initializeWasm() must be awaited first!");
10563 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
10564 return nativeResponseValue;
10566 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
10568 export function CResult_PaymentIdPaymentSendFailureZ_err(e: number): number {
10569 if(!isWasmInitialized) {
10570 throw new Error("initializeWasm() must be awaited first!");
10572 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
10573 return nativeResponseValue;
10575 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
10577 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: number): boolean {
10578 if(!isWasmInitialized) {
10579 throw new Error("initializeWasm() must be awaited first!");
10581 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
10582 return nativeResponseValue;
10584 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
10586 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: number): void {
10587 if(!isWasmInitialized) {
10588 throw new Error("initializeWasm() must be awaited first!");
10590 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
10591 // debug statements here
10593 // uintptr_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
10595 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: number): number {
10596 if(!isWasmInitialized) {
10597 throw new Error("initializeWasm() must be awaited first!");
10599 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
10600 return nativeResponseValue;
10602 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
10604 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: number): number {
10605 if(!isWasmInitialized) {
10606 throw new Error("initializeWasm() must be awaited first!");
10608 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
10609 return nativeResponseValue;
10611 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
10613 export function CResult_NonePaymentSendFailureZ_ok(): number {
10614 if(!isWasmInitialized) {
10615 throw new Error("initializeWasm() must be awaited first!");
10617 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
10618 return nativeResponseValue;
10620 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
10622 export function CResult_NonePaymentSendFailureZ_err(e: number): number {
10623 if(!isWasmInitialized) {
10624 throw new Error("initializeWasm() must be awaited first!");
10626 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
10627 return nativeResponseValue;
10629 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
10631 export function CResult_NonePaymentSendFailureZ_is_ok(o: number): boolean {
10632 if(!isWasmInitialized) {
10633 throw new Error("initializeWasm() must be awaited first!");
10635 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
10636 return nativeResponseValue;
10638 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
10640 export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
10641 if(!isWasmInitialized) {
10642 throw new Error("initializeWasm() must be awaited first!");
10644 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
10645 // debug statements here
10647 // uintptr_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
10649 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: number): number {
10650 if(!isWasmInitialized) {
10651 throw new Error("initializeWasm() must be awaited first!");
10653 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
10654 return nativeResponseValue;
10656 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
10658 export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
10659 if(!isWasmInitialized) {
10660 throw new Error("initializeWasm() must be awaited first!");
10662 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
10663 return nativeResponseValue;
10665 // uintptr_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
10667 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: number): number {
10668 if(!isWasmInitialized) {
10669 throw new Error("initializeWasm() must be awaited first!");
10671 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
10672 return nativeResponseValue;
10674 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
10676 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: number): number {
10677 if(!isWasmInitialized) {
10678 throw new Error("initializeWasm() must be awaited first!");
10680 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
10681 return nativeResponseValue;
10683 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
10685 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): number {
10686 if(!isWasmInitialized) {
10687 throw new Error("initializeWasm() must be awaited first!");
10689 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
10690 return nativeResponseValue;
10692 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
10694 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: number): void {
10695 if(!isWasmInitialized) {
10696 throw new Error("initializeWasm() must be awaited first!");
10698 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
10699 // debug statements here
10701 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
10703 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: number): number {
10704 if(!isWasmInitialized) {
10705 throw new Error("initializeWasm() must be awaited first!");
10707 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
10708 return nativeResponseValue;
10710 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
10712 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: number): number {
10713 if(!isWasmInitialized) {
10714 throw new Error("initializeWasm() must be awaited first!");
10716 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
10717 return nativeResponseValue;
10719 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
10721 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: number): boolean {
10722 if(!isWasmInitialized) {
10723 throw new Error("initializeWasm() must be awaited first!");
10725 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
10726 return nativeResponseValue;
10728 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
10730 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: number): void {
10731 if(!isWasmInitialized) {
10732 throw new Error("initializeWasm() must be awaited first!");
10734 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
10735 // debug statements here
10737 // uintptr_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
10739 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: number): number {
10740 if(!isWasmInitialized) {
10741 throw new Error("initializeWasm() must be awaited first!");
10743 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
10744 return nativeResponseValue;
10746 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
10748 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: number): number {
10749 if(!isWasmInitialized) {
10750 throw new Error("initializeWasm() must be awaited first!");
10752 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
10753 return nativeResponseValue;
10755 // uintptr_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
10757 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: number): number {
10758 if(!isWasmInitialized) {
10759 throw new Error("initializeWasm() must be awaited first!");
10761 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
10762 return nativeResponseValue;
10764 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
10766 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: number): number {
10767 if(!isWasmInitialized) {
10768 throw new Error("initializeWasm() must be awaited first!");
10770 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
10771 return nativeResponseValue;
10773 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
10775 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): number {
10776 if(!isWasmInitialized) {
10777 throw new Error("initializeWasm() must be awaited first!");
10779 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
10780 return nativeResponseValue;
10782 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
10784 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: number): void {
10785 if(!isWasmInitialized) {
10786 throw new Error("initializeWasm() must be awaited first!");
10788 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
10789 // debug statements here
10791 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
10793 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: number): number {
10794 if(!isWasmInitialized) {
10795 throw new Error("initializeWasm() must be awaited first!");
10797 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
10798 return nativeResponseValue;
10800 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
10802 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): number {
10803 if(!isWasmInitialized) {
10804 throw new Error("initializeWasm() must be awaited first!");
10806 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
10807 return nativeResponseValue;
10809 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
10811 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: number): boolean {
10812 if(!isWasmInitialized) {
10813 throw new Error("initializeWasm() must be awaited first!");
10815 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
10816 return nativeResponseValue;
10818 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
10820 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: number): void {
10821 if(!isWasmInitialized) {
10822 throw new Error("initializeWasm() must be awaited first!");
10824 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
10825 // debug statements here
10827 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
10829 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: number): number {
10830 if(!isWasmInitialized) {
10831 throw new Error("initializeWasm() must be awaited first!");
10833 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
10834 return nativeResponseValue;
10836 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
10838 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: number): number {
10839 if(!isWasmInitialized) {
10840 throw new Error("initializeWasm() must be awaited first!");
10842 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
10843 return nativeResponseValue;
10845 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
10847 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: number): number {
10848 if(!isWasmInitialized) {
10849 throw new Error("initializeWasm() must be awaited first!");
10851 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
10852 return nativeResponseValue;
10854 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
10856 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: number): number {
10857 if(!isWasmInitialized) {
10858 throw new Error("initializeWasm() must be awaited first!");
10860 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
10861 return nativeResponseValue;
10863 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
10865 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: number): boolean {
10866 if(!isWasmInitialized) {
10867 throw new Error("initializeWasm() must be awaited first!");
10869 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
10870 return nativeResponseValue;
10872 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
10874 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: number): void {
10875 if(!isWasmInitialized) {
10876 throw new Error("initializeWasm() must be awaited first!");
10878 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
10879 // debug statements here
10881 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
10883 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: number): number {
10884 if(!isWasmInitialized) {
10885 throw new Error("initializeWasm() must be awaited first!");
10887 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
10888 return nativeResponseValue;
10890 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
10892 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: number): number {
10893 if(!isWasmInitialized) {
10894 throw new Error("initializeWasm() must be awaited first!");
10896 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
10897 return nativeResponseValue;
10899 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
10901 export function CResult_PaymentSecretNoneZ_ok(o: number): number {
10902 if(!isWasmInitialized) {
10903 throw new Error("initializeWasm() must be awaited first!");
10905 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
10906 return nativeResponseValue;
10908 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
10910 export function CResult_PaymentSecretNoneZ_err(): number {
10911 if(!isWasmInitialized) {
10912 throw new Error("initializeWasm() must be awaited first!");
10914 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
10915 return nativeResponseValue;
10917 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
10919 export function CResult_PaymentSecretNoneZ_is_ok(o: number): boolean {
10920 if(!isWasmInitialized) {
10921 throw new Error("initializeWasm() must be awaited first!");
10923 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
10924 return nativeResponseValue;
10926 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
10928 export function CResult_PaymentSecretNoneZ_free(_res: number): void {
10929 if(!isWasmInitialized) {
10930 throw new Error("initializeWasm() must be awaited first!");
10932 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
10933 // debug statements here
10935 // uintptr_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
10937 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: number): number {
10938 if(!isWasmInitialized) {
10939 throw new Error("initializeWasm() must be awaited first!");
10941 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
10942 return nativeResponseValue;
10944 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
10946 export function CResult_PaymentSecretNoneZ_clone(orig: number): number {
10947 if(!isWasmInitialized) {
10948 throw new Error("initializeWasm() must be awaited first!");
10950 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
10951 return nativeResponseValue;
10953 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
10955 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): number {
10956 if(!isWasmInitialized) {
10957 throw new Error("initializeWasm() must be awaited first!");
10959 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
10960 return nativeResponseValue;
10962 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
10964 export function CResult_PaymentSecretAPIErrorZ_err(e: number): number {
10965 if(!isWasmInitialized) {
10966 throw new Error("initializeWasm() must be awaited first!");
10968 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
10969 return nativeResponseValue;
10971 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
10973 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: number): boolean {
10974 if(!isWasmInitialized) {
10975 throw new Error("initializeWasm() must be awaited first!");
10977 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
10978 return nativeResponseValue;
10980 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
10982 export function CResult_PaymentSecretAPIErrorZ_free(_res: number): void {
10983 if(!isWasmInitialized) {
10984 throw new Error("initializeWasm() must be awaited first!");
10986 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
10987 // debug statements here
10989 // uintptr_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
10991 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: number): number {
10992 if(!isWasmInitialized) {
10993 throw new Error("initializeWasm() must be awaited first!");
10995 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
10996 return nativeResponseValue;
10998 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
11000 export function CResult_PaymentSecretAPIErrorZ_clone(orig: number): number {
11001 if(!isWasmInitialized) {
11002 throw new Error("initializeWasm() must be awaited first!");
11004 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
11005 return nativeResponseValue;
11007 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
11009 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): number {
11010 if(!isWasmInitialized) {
11011 throw new Error("initializeWasm() must be awaited first!");
11013 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
11014 return nativeResponseValue;
11016 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
11018 export function CResult_PaymentPreimageAPIErrorZ_err(e: number): number {
11019 if(!isWasmInitialized) {
11020 throw new Error("initializeWasm() must be awaited first!");
11022 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
11023 return nativeResponseValue;
11025 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
11027 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: number): boolean {
11028 if(!isWasmInitialized) {
11029 throw new Error("initializeWasm() must be awaited first!");
11031 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
11032 return nativeResponseValue;
11034 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
11036 export function CResult_PaymentPreimageAPIErrorZ_free(_res: number): void {
11037 if(!isWasmInitialized) {
11038 throw new Error("initializeWasm() must be awaited first!");
11040 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
11041 // debug statements here
11043 // uintptr_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
11045 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: number): number {
11046 if(!isWasmInitialized) {
11047 throw new Error("initializeWasm() must be awaited first!");
11049 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
11050 return nativeResponseValue;
11052 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
11054 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: number): number {
11055 if(!isWasmInitialized) {
11056 throw new Error("initializeWasm() must be awaited first!");
11058 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
11059 return nativeResponseValue;
11061 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
11063 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: number): number {
11064 if(!isWasmInitialized) {
11065 throw new Error("initializeWasm() must be awaited first!");
11067 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
11068 return nativeResponseValue;
11070 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
11072 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: number): number {
11073 if(!isWasmInitialized) {
11074 throw new Error("initializeWasm() must be awaited first!");
11076 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
11077 return nativeResponseValue;
11079 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
11081 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: number): boolean {
11082 if(!isWasmInitialized) {
11083 throw new Error("initializeWasm() must be awaited first!");
11085 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
11086 return nativeResponseValue;
11088 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
11090 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: number): void {
11091 if(!isWasmInitialized) {
11092 throw new Error("initializeWasm() must be awaited first!");
11094 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
11095 // debug statements here
11097 // uintptr_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
11099 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: number): number {
11100 if(!isWasmInitialized) {
11101 throw new Error("initializeWasm() must be awaited first!");
11103 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
11104 return nativeResponseValue;
11106 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
11108 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: number): number {
11109 if(!isWasmInitialized) {
11110 throw new Error("initializeWasm() must be awaited first!");
11112 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
11113 return nativeResponseValue;
11115 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
11117 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: number): number {
11118 if(!isWasmInitialized) {
11119 throw new Error("initializeWasm() must be awaited first!");
11121 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
11122 return nativeResponseValue;
11124 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
11126 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: number): number {
11127 if(!isWasmInitialized) {
11128 throw new Error("initializeWasm() must be awaited first!");
11130 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
11131 return nativeResponseValue;
11133 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
11135 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: number): boolean {
11136 if(!isWasmInitialized) {
11137 throw new Error("initializeWasm() must be awaited first!");
11139 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
11140 return nativeResponseValue;
11142 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
11144 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: number): void {
11145 if(!isWasmInitialized) {
11146 throw new Error("initializeWasm() must be awaited first!");
11148 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
11149 // debug statements here
11151 // uintptr_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
11153 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: number): number {
11154 if(!isWasmInitialized) {
11155 throw new Error("initializeWasm() must be awaited first!");
11157 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
11158 return nativeResponseValue;
11160 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
11162 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: number): number {
11163 if(!isWasmInitialized) {
11164 throw new Error("initializeWasm() must be awaited first!");
11166 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
11167 return nativeResponseValue;
11169 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
11171 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: number): number {
11172 if(!isWasmInitialized) {
11173 throw new Error("initializeWasm() must be awaited first!");
11175 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
11176 return nativeResponseValue;
11178 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
11180 export function CResult_ChannelDetailsDecodeErrorZ_err(e: number): number {
11181 if(!isWasmInitialized) {
11182 throw new Error("initializeWasm() must be awaited first!");
11184 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
11185 return nativeResponseValue;
11187 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
11189 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: number): boolean {
11190 if(!isWasmInitialized) {
11191 throw new Error("initializeWasm() must be awaited first!");
11193 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
11194 return nativeResponseValue;
11196 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
11198 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: number): void {
11199 if(!isWasmInitialized) {
11200 throw new Error("initializeWasm() must be awaited first!");
11202 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
11203 // debug statements here
11205 // uintptr_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
11207 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: number): number {
11208 if(!isWasmInitialized) {
11209 throw new Error("initializeWasm() must be awaited first!");
11211 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
11212 return nativeResponseValue;
11214 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
11216 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: number): number {
11217 if(!isWasmInitialized) {
11218 throw new Error("initializeWasm() must be awaited first!");
11220 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
11221 return nativeResponseValue;
11223 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
11225 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: number): number {
11226 if(!isWasmInitialized) {
11227 throw new Error("initializeWasm() must be awaited first!");
11229 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
11230 return nativeResponseValue;
11232 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
11234 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: number): number {
11235 if(!isWasmInitialized) {
11236 throw new Error("initializeWasm() must be awaited first!");
11238 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
11239 return nativeResponseValue;
11241 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
11243 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: number): boolean {
11244 if(!isWasmInitialized) {
11245 throw new Error("initializeWasm() must be awaited first!");
11247 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
11248 return nativeResponseValue;
11250 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
11252 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: number): void {
11253 if(!isWasmInitialized) {
11254 throw new Error("initializeWasm() must be awaited first!");
11256 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
11257 // debug statements here
11259 // uintptr_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
11261 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: number): number {
11262 if(!isWasmInitialized) {
11263 throw new Error("initializeWasm() must be awaited first!");
11265 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
11266 return nativeResponseValue;
11268 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
11270 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: number): number {
11271 if(!isWasmInitialized) {
11272 throw new Error("initializeWasm() must be awaited first!");
11274 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
11275 return nativeResponseValue;
11277 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
11279 export function CVec_ChannelMonitorZ_free(_res: number): void {
11280 if(!isWasmInitialized) {
11281 throw new Error("initializeWasm() must be awaited first!");
11283 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
11284 // debug statements here
11286 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
11288 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: number): number {
11289 if(!isWasmInitialized) {
11290 throw new Error("initializeWasm() must be awaited first!");
11292 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
11293 return nativeResponseValue;
11295 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
11297 export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
11298 if(!isWasmInitialized) {
11299 throw new Error("initializeWasm() must be awaited first!");
11301 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
11302 // debug statements here
11304 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
11306 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
11307 if(!isWasmInitialized) {
11308 throw new Error("initializeWasm() must be awaited first!");
11310 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
11311 return nativeResponseValue;
11313 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
11315 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
11316 if(!isWasmInitialized) {
11317 throw new Error("initializeWasm() must be awaited first!");
11319 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
11320 return nativeResponseValue;
11322 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
11324 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: number): boolean {
11325 if(!isWasmInitialized) {
11326 throw new Error("initializeWasm() must be awaited first!");
11328 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
11329 return nativeResponseValue;
11331 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
11333 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
11334 if(!isWasmInitialized) {
11335 throw new Error("initializeWasm() must be awaited first!");
11337 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
11338 // debug statements here
11340 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
11342 export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
11343 if(!isWasmInitialized) {
11344 throw new Error("initializeWasm() must be awaited first!");
11346 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
11347 return nativeResponseValue;
11349 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
11351 export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
11352 if(!isWasmInitialized) {
11353 throw new Error("initializeWasm() must be awaited first!");
11355 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
11356 return nativeResponseValue;
11358 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
11360 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: number): boolean {
11361 if(!isWasmInitialized) {
11362 throw new Error("initializeWasm() must be awaited first!");
11364 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
11365 return nativeResponseValue;
11367 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
11369 export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
11370 if(!isWasmInitialized) {
11371 throw new Error("initializeWasm() must be awaited first!");
11373 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
11374 // debug statements here
11376 // uintptr_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
11378 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: number): number {
11379 if(!isWasmInitialized) {
11380 throw new Error("initializeWasm() must be awaited first!");
11382 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
11383 return nativeResponseValue;
11385 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
11387 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
11388 if(!isWasmInitialized) {
11389 throw new Error("initializeWasm() must be awaited first!");
11391 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
11392 return nativeResponseValue;
11394 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
11396 export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
11397 if(!isWasmInitialized) {
11398 throw new Error("initializeWasm() must be awaited first!");
11400 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
11401 return nativeResponseValue;
11403 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
11405 export function CResult_OutPointDecodeErrorZ_err(e: number): number {
11406 if(!isWasmInitialized) {
11407 throw new Error("initializeWasm() must be awaited first!");
11409 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
11410 return nativeResponseValue;
11412 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
11414 export function CResult_OutPointDecodeErrorZ_is_ok(o: number): boolean {
11415 if(!isWasmInitialized) {
11416 throw new Error("initializeWasm() must be awaited first!");
11418 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
11419 return nativeResponseValue;
11421 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
11423 export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
11424 if(!isWasmInitialized) {
11425 throw new Error("initializeWasm() must be awaited first!");
11427 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
11428 // debug statements here
11430 // uintptr_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
11432 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: number): number {
11433 if(!isWasmInitialized) {
11434 throw new Error("initializeWasm() must be awaited first!");
11436 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
11437 return nativeResponseValue;
11439 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
11441 export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
11442 if(!isWasmInitialized) {
11443 throw new Error("initializeWasm() must be awaited first!");
11445 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
11446 return nativeResponseValue;
11448 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
11450 export function COption_TypeZ_some(o: number): number {
11451 if(!isWasmInitialized) {
11452 throw new Error("initializeWasm() must be awaited first!");
11454 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
11455 return nativeResponseValue;
11457 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
11459 export function COption_TypeZ_none(): number {
11460 if(!isWasmInitialized) {
11461 throw new Error("initializeWasm() must be awaited first!");
11463 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
11464 return nativeResponseValue;
11466 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
11468 export function COption_TypeZ_free(_res: number): void {
11469 if(!isWasmInitialized) {
11470 throw new Error("initializeWasm() must be awaited first!");
11472 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
11473 // debug statements here
11475 // uintptr_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
11477 export function COption_TypeZ_clone_ptr(arg: number): number {
11478 if(!isWasmInitialized) {
11479 throw new Error("initializeWasm() must be awaited first!");
11481 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
11482 return nativeResponseValue;
11484 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
11486 export function COption_TypeZ_clone(orig: number): number {
11487 if(!isWasmInitialized) {
11488 throw new Error("initializeWasm() must be awaited first!");
11490 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
11491 return nativeResponseValue;
11493 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
11495 export function CResult_COption_TypeZDecodeErrorZ_ok(o: number): number {
11496 if(!isWasmInitialized) {
11497 throw new Error("initializeWasm() must be awaited first!");
11499 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
11500 return nativeResponseValue;
11502 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
11504 export function CResult_COption_TypeZDecodeErrorZ_err(e: number): number {
11505 if(!isWasmInitialized) {
11506 throw new Error("initializeWasm() must be awaited first!");
11508 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
11509 return nativeResponseValue;
11511 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
11513 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: number): boolean {
11514 if(!isWasmInitialized) {
11515 throw new Error("initializeWasm() must be awaited first!");
11517 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
11518 return nativeResponseValue;
11520 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
11522 export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
11523 if(!isWasmInitialized) {
11524 throw new Error("initializeWasm() must be awaited first!");
11526 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
11527 // debug statements here
11529 // uintptr_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
11531 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: number): number {
11532 if(!isWasmInitialized) {
11533 throw new Error("initializeWasm() must be awaited first!");
11535 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
11536 return nativeResponseValue;
11538 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
11540 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
11541 if(!isWasmInitialized) {
11542 throw new Error("initializeWasm() must be awaited first!");
11544 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
11545 return nativeResponseValue;
11547 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
11549 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): number {
11550 if(!isWasmInitialized) {
11551 throw new Error("initializeWasm() must be awaited first!");
11553 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
11554 return nativeResponseValue;
11556 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
11558 export function CResult_PaymentIdPaymentErrorZ_err(e: number): number {
11559 if(!isWasmInitialized) {
11560 throw new Error("initializeWasm() must be awaited first!");
11562 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
11563 return nativeResponseValue;
11565 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
11567 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: number): boolean {
11568 if(!isWasmInitialized) {
11569 throw new Error("initializeWasm() must be awaited first!");
11571 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
11572 return nativeResponseValue;
11574 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
11576 export function CResult_PaymentIdPaymentErrorZ_free(_res: number): void {
11577 if(!isWasmInitialized) {
11578 throw new Error("initializeWasm() must be awaited first!");
11580 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
11581 // debug statements here
11583 // uintptr_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
11585 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: number): number {
11586 if(!isWasmInitialized) {
11587 throw new Error("initializeWasm() must be awaited first!");
11589 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
11590 return nativeResponseValue;
11592 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
11594 export function CResult_PaymentIdPaymentErrorZ_clone(orig: number): number {
11595 if(!isWasmInitialized) {
11596 throw new Error("initializeWasm() must be awaited first!");
11598 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
11599 return nativeResponseValue;
11601 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
11603 export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): number {
11604 if(!isWasmInitialized) {
11605 throw new Error("initializeWasm() must be awaited first!");
11607 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
11608 return nativeResponseValue;
11610 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
11612 export function CResult_SiPrefixParseErrorZ_err(e: number): number {
11613 if(!isWasmInitialized) {
11614 throw new Error("initializeWasm() must be awaited first!");
11616 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
11617 return nativeResponseValue;
11619 // bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
11621 export function CResult_SiPrefixParseErrorZ_is_ok(o: number): boolean {
11622 if(!isWasmInitialized) {
11623 throw new Error("initializeWasm() must be awaited first!");
11625 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
11626 return nativeResponseValue;
11628 // void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
11630 export function CResult_SiPrefixParseErrorZ_free(_res: number): void {
11631 if(!isWasmInitialized) {
11632 throw new Error("initializeWasm() must be awaited first!");
11634 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
11635 // debug statements here
11637 // uintptr_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
11639 export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: number): number {
11640 if(!isWasmInitialized) {
11641 throw new Error("initializeWasm() must be awaited first!");
11643 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
11644 return nativeResponseValue;
11646 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
11648 export function CResult_SiPrefixParseErrorZ_clone(orig: number): number {
11649 if(!isWasmInitialized) {
11650 throw new Error("initializeWasm() must be awaited first!");
11652 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
11653 return nativeResponseValue;
11655 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
11657 export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: number): number {
11658 if(!isWasmInitialized) {
11659 throw new Error("initializeWasm() must be awaited first!");
11661 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
11662 return nativeResponseValue;
11664 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
11666 export function CResult_InvoiceParseOrSemanticErrorZ_err(e: number): number {
11667 if(!isWasmInitialized) {
11668 throw new Error("initializeWasm() must be awaited first!");
11670 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
11671 return nativeResponseValue;
11673 // bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
11675 export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: number): boolean {
11676 if(!isWasmInitialized) {
11677 throw new Error("initializeWasm() must be awaited first!");
11679 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
11680 return nativeResponseValue;
11682 // void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
11684 export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: number): void {
11685 if(!isWasmInitialized) {
11686 throw new Error("initializeWasm() must be awaited first!");
11688 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
11689 // debug statements here
11691 // uintptr_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
11693 export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: number): number {
11694 if(!isWasmInitialized) {
11695 throw new Error("initializeWasm() must be awaited first!");
11697 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
11698 return nativeResponseValue;
11700 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
11702 export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: number): number {
11703 if(!isWasmInitialized) {
11704 throw new Error("initializeWasm() must be awaited first!");
11706 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
11707 return nativeResponseValue;
11709 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
11711 export function CResult_SignedRawInvoiceParseErrorZ_ok(o: number): number {
11712 if(!isWasmInitialized) {
11713 throw new Error("initializeWasm() must be awaited first!");
11715 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
11716 return nativeResponseValue;
11718 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
11720 export function CResult_SignedRawInvoiceParseErrorZ_err(e: number): number {
11721 if(!isWasmInitialized) {
11722 throw new Error("initializeWasm() must be awaited first!");
11724 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
11725 return nativeResponseValue;
11727 // bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
11729 export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: number): boolean {
11730 if(!isWasmInitialized) {
11731 throw new Error("initializeWasm() must be awaited first!");
11733 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
11734 return nativeResponseValue;
11736 // void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
11738 export function CResult_SignedRawInvoiceParseErrorZ_free(_res: number): void {
11739 if(!isWasmInitialized) {
11740 throw new Error("initializeWasm() must be awaited first!");
11742 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
11743 // debug statements here
11745 // uintptr_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
11747 export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: number): number {
11748 if(!isWasmInitialized) {
11749 throw new Error("initializeWasm() must be awaited first!");
11751 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
11752 return nativeResponseValue;
11754 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
11756 export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: number): number {
11757 if(!isWasmInitialized) {
11758 throw new Error("initializeWasm() must be awaited first!");
11760 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
11761 return nativeResponseValue;
11763 // uintptr_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
11765 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: number): number {
11766 if(!isWasmInitialized) {
11767 throw new Error("initializeWasm() must be awaited first!");
11769 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
11770 return nativeResponseValue;
11772 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
11774 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: number): number {
11775 if(!isWasmInitialized) {
11776 throw new Error("initializeWasm() must be awaited first!");
11778 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
11779 return nativeResponseValue;
11781 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
11783 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: number, b: number, c: number): number {
11784 if(!isWasmInitialized) {
11785 throw new Error("initializeWasm() must be awaited first!");
11787 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
11788 return nativeResponseValue;
11790 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
11792 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: number): void {
11793 if(!isWasmInitialized) {
11794 throw new Error("initializeWasm() must be awaited first!");
11796 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
11797 // debug statements here
11799 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
11801 export function CResult_PayeePubKeyErrorZ_ok(o: number): number {
11802 if(!isWasmInitialized) {
11803 throw new Error("initializeWasm() must be awaited first!");
11805 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
11806 return nativeResponseValue;
11808 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
11810 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): number {
11811 if(!isWasmInitialized) {
11812 throw new Error("initializeWasm() must be awaited first!");
11814 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
11815 return nativeResponseValue;
11817 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
11819 export function CResult_PayeePubKeyErrorZ_is_ok(o: number): boolean {
11820 if(!isWasmInitialized) {
11821 throw new Error("initializeWasm() must be awaited first!");
11823 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
11824 return nativeResponseValue;
11826 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
11828 export function CResult_PayeePubKeyErrorZ_free(_res: number): void {
11829 if(!isWasmInitialized) {
11830 throw new Error("initializeWasm() must be awaited first!");
11832 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
11833 // debug statements here
11835 // uintptr_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
11837 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: number): number {
11838 if(!isWasmInitialized) {
11839 throw new Error("initializeWasm() must be awaited first!");
11841 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
11842 return nativeResponseValue;
11844 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
11846 export function CResult_PayeePubKeyErrorZ_clone(orig: number): number {
11847 if(!isWasmInitialized) {
11848 throw new Error("initializeWasm() must be awaited first!");
11850 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
11851 return nativeResponseValue;
11853 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
11855 export function CVec_PrivateRouteZ_free(_res: number): void {
11856 if(!isWasmInitialized) {
11857 throw new Error("initializeWasm() must be awaited first!");
11859 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
11860 // debug statements here
11862 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
11864 export function CResult_PositiveTimestampCreationErrorZ_ok(o: number): number {
11865 if(!isWasmInitialized) {
11866 throw new Error("initializeWasm() must be awaited first!");
11868 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
11869 return nativeResponseValue;
11871 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
11873 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): number {
11874 if(!isWasmInitialized) {
11875 throw new Error("initializeWasm() must be awaited first!");
11877 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
11878 return nativeResponseValue;
11880 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
11882 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: number): boolean {
11883 if(!isWasmInitialized) {
11884 throw new Error("initializeWasm() must be awaited first!");
11886 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
11887 return nativeResponseValue;
11889 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
11891 export function CResult_PositiveTimestampCreationErrorZ_free(_res: number): void {
11892 if(!isWasmInitialized) {
11893 throw new Error("initializeWasm() must be awaited first!");
11895 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
11896 // debug statements here
11898 // uintptr_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
11900 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: number): number {
11901 if(!isWasmInitialized) {
11902 throw new Error("initializeWasm() must be awaited first!");
11904 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
11905 return nativeResponseValue;
11907 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
11909 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: number): number {
11910 if(!isWasmInitialized) {
11911 throw new Error("initializeWasm() must be awaited first!");
11913 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
11914 return nativeResponseValue;
11916 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
11918 export function CResult_NoneSemanticErrorZ_ok(): number {
11919 if(!isWasmInitialized) {
11920 throw new Error("initializeWasm() must be awaited first!");
11922 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
11923 return nativeResponseValue;
11925 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
11927 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): number {
11928 if(!isWasmInitialized) {
11929 throw new Error("initializeWasm() must be awaited first!");
11931 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
11932 return nativeResponseValue;
11934 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
11936 export function CResult_NoneSemanticErrorZ_is_ok(o: number): boolean {
11937 if(!isWasmInitialized) {
11938 throw new Error("initializeWasm() must be awaited first!");
11940 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
11941 return nativeResponseValue;
11943 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
11945 export function CResult_NoneSemanticErrorZ_free(_res: number): void {
11946 if(!isWasmInitialized) {
11947 throw new Error("initializeWasm() must be awaited first!");
11949 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
11950 // debug statements here
11952 // uintptr_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
11954 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: number): number {
11955 if(!isWasmInitialized) {
11956 throw new Error("initializeWasm() must be awaited first!");
11958 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
11959 return nativeResponseValue;
11961 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
11963 export function CResult_NoneSemanticErrorZ_clone(orig: number): number {
11964 if(!isWasmInitialized) {
11965 throw new Error("initializeWasm() must be awaited first!");
11967 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
11968 return nativeResponseValue;
11970 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
11972 export function CResult_InvoiceSemanticErrorZ_ok(o: number): number {
11973 if(!isWasmInitialized) {
11974 throw new Error("initializeWasm() must be awaited first!");
11976 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
11977 return nativeResponseValue;
11979 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
11981 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): number {
11982 if(!isWasmInitialized) {
11983 throw new Error("initializeWasm() must be awaited first!");
11985 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
11986 return nativeResponseValue;
11988 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
11990 export function CResult_InvoiceSemanticErrorZ_is_ok(o: number): boolean {
11991 if(!isWasmInitialized) {
11992 throw new Error("initializeWasm() must be awaited first!");
11994 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
11995 return nativeResponseValue;
11997 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
11999 export function CResult_InvoiceSemanticErrorZ_free(_res: number): void {
12000 if(!isWasmInitialized) {
12001 throw new Error("initializeWasm() must be awaited first!");
12003 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
12004 // debug statements here
12006 // uintptr_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
12008 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: number): number {
12009 if(!isWasmInitialized) {
12010 throw new Error("initializeWasm() must be awaited first!");
12012 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
12013 return nativeResponseValue;
12015 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
12017 export function CResult_InvoiceSemanticErrorZ_clone(orig: number): number {
12018 if(!isWasmInitialized) {
12019 throw new Error("initializeWasm() must be awaited first!");
12021 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
12022 return nativeResponseValue;
12024 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
12026 export function CResult_DescriptionCreationErrorZ_ok(o: number): number {
12027 if(!isWasmInitialized) {
12028 throw new Error("initializeWasm() must be awaited first!");
12030 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
12031 return nativeResponseValue;
12033 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
12035 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): number {
12036 if(!isWasmInitialized) {
12037 throw new Error("initializeWasm() must be awaited first!");
12039 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
12040 return nativeResponseValue;
12042 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
12044 export function CResult_DescriptionCreationErrorZ_is_ok(o: number): boolean {
12045 if(!isWasmInitialized) {
12046 throw new Error("initializeWasm() must be awaited first!");
12048 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
12049 return nativeResponseValue;
12051 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
12053 export function CResult_DescriptionCreationErrorZ_free(_res: number): void {
12054 if(!isWasmInitialized) {
12055 throw new Error("initializeWasm() must be awaited first!");
12057 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
12058 // debug statements here
12060 // uintptr_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
12062 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: number): number {
12063 if(!isWasmInitialized) {
12064 throw new Error("initializeWasm() must be awaited first!");
12066 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
12067 return nativeResponseValue;
12069 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
12071 export function CResult_DescriptionCreationErrorZ_clone(orig: number): number {
12072 if(!isWasmInitialized) {
12073 throw new Error("initializeWasm() must be awaited first!");
12075 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
12076 return nativeResponseValue;
12078 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
12080 export function CResult_PrivateRouteCreationErrorZ_ok(o: number): number {
12081 if(!isWasmInitialized) {
12082 throw new Error("initializeWasm() must be awaited first!");
12084 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
12085 return nativeResponseValue;
12087 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
12089 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): number {
12090 if(!isWasmInitialized) {
12091 throw new Error("initializeWasm() must be awaited first!");
12093 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
12094 return nativeResponseValue;
12096 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
12098 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: number): boolean {
12099 if(!isWasmInitialized) {
12100 throw new Error("initializeWasm() must be awaited first!");
12102 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
12103 return nativeResponseValue;
12105 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
12107 export function CResult_PrivateRouteCreationErrorZ_free(_res: number): void {
12108 if(!isWasmInitialized) {
12109 throw new Error("initializeWasm() must be awaited first!");
12111 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
12112 // debug statements here
12114 // uintptr_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
12116 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: number): number {
12117 if(!isWasmInitialized) {
12118 throw new Error("initializeWasm() must be awaited first!");
12120 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
12121 return nativeResponseValue;
12123 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
12125 export function CResult_PrivateRouteCreationErrorZ_clone(orig: number): number {
12126 if(!isWasmInitialized) {
12127 throw new Error("initializeWasm() must be awaited first!");
12129 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
12130 return nativeResponseValue;
12132 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
12134 export function CResult_StringErrorZ_ok(o: number): number {
12135 if(!isWasmInitialized) {
12136 throw new Error("initializeWasm() must be awaited first!");
12138 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
12139 return nativeResponseValue;
12141 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
12143 export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
12144 if(!isWasmInitialized) {
12145 throw new Error("initializeWasm() must be awaited first!");
12147 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
12148 return nativeResponseValue;
12150 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
12152 export function CResult_StringErrorZ_is_ok(o: number): boolean {
12153 if(!isWasmInitialized) {
12154 throw new Error("initializeWasm() must be awaited first!");
12156 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
12157 return nativeResponseValue;
12159 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
12161 export function CResult_StringErrorZ_free(_res: number): void {
12162 if(!isWasmInitialized) {
12163 throw new Error("initializeWasm() must be awaited first!");
12165 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
12166 // debug statements here
12168 // uintptr_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg);
12170 export function CResult_StringErrorZ_clone_ptr(arg: number): number {
12171 if(!isWasmInitialized) {
12172 throw new Error("initializeWasm() must be awaited first!");
12174 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone_ptr(arg);
12175 return nativeResponseValue;
12177 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_clone(const struct LDKCResult_StringErrorZ *NONNULL_PTR orig);
12179 export function CResult_StringErrorZ_clone(orig: number): number {
12180 if(!isWasmInitialized) {
12181 throw new Error("initializeWasm() must be awaited first!");
12183 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
12184 return nativeResponseValue;
12186 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
12188 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
12189 if(!isWasmInitialized) {
12190 throw new Error("initializeWasm() must be awaited first!");
12192 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
12193 return nativeResponseValue;
12195 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12197 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
12198 if(!isWasmInitialized) {
12199 throw new Error("initializeWasm() must be awaited first!");
12201 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
12202 return nativeResponseValue;
12204 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
12206 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: number): boolean {
12207 if(!isWasmInitialized) {
12208 throw new Error("initializeWasm() must be awaited first!");
12210 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
12211 return nativeResponseValue;
12213 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
12215 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
12216 if(!isWasmInitialized) {
12217 throw new Error("initializeWasm() must be awaited first!");
12219 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
12220 // debug statements here
12222 // uintptr_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
12224 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: number): number {
12225 if(!isWasmInitialized) {
12226 throw new Error("initializeWasm() must be awaited first!");
12228 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
12229 return nativeResponseValue;
12231 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
12233 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
12234 if(!isWasmInitialized) {
12235 throw new Error("initializeWasm() must be awaited first!");
12237 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
12238 return nativeResponseValue;
12240 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
12242 export function COption_MonitorEventZ_some(o: number): number {
12243 if(!isWasmInitialized) {
12244 throw new Error("initializeWasm() must be awaited first!");
12246 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
12247 return nativeResponseValue;
12249 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
12251 export function COption_MonitorEventZ_none(): number {
12252 if(!isWasmInitialized) {
12253 throw new Error("initializeWasm() must be awaited first!");
12255 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
12256 return nativeResponseValue;
12258 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
12260 export function COption_MonitorEventZ_free(_res: number): void {
12261 if(!isWasmInitialized) {
12262 throw new Error("initializeWasm() must be awaited first!");
12264 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
12265 // debug statements here
12267 // uintptr_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
12269 export function COption_MonitorEventZ_clone_ptr(arg: number): number {
12270 if(!isWasmInitialized) {
12271 throw new Error("initializeWasm() must be awaited first!");
12273 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
12274 return nativeResponseValue;
12276 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
12278 export function COption_MonitorEventZ_clone(orig: number): number {
12279 if(!isWasmInitialized) {
12280 throw new Error("initializeWasm() must be awaited first!");
12282 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
12283 return nativeResponseValue;
12285 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
12287 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: number): number {
12288 if(!isWasmInitialized) {
12289 throw new Error("initializeWasm() must be awaited first!");
12291 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
12292 return nativeResponseValue;
12294 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
12296 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: number): number {
12297 if(!isWasmInitialized) {
12298 throw new Error("initializeWasm() must be awaited first!");
12300 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
12301 return nativeResponseValue;
12303 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
12305 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: number): boolean {
12306 if(!isWasmInitialized) {
12307 throw new Error("initializeWasm() must be awaited first!");
12309 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
12310 return nativeResponseValue;
12312 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
12314 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: number): void {
12315 if(!isWasmInitialized) {
12316 throw new Error("initializeWasm() must be awaited first!");
12318 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
12319 // debug statements here
12321 // uintptr_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
12323 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: number): number {
12324 if(!isWasmInitialized) {
12325 throw new Error("initializeWasm() must be awaited first!");
12327 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
12328 return nativeResponseValue;
12330 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
12332 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: number): number {
12333 if(!isWasmInitialized) {
12334 throw new Error("initializeWasm() must be awaited first!");
12336 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
12337 return nativeResponseValue;
12339 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
12341 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
12342 if(!isWasmInitialized) {
12343 throw new Error("initializeWasm() must be awaited first!");
12345 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
12346 return nativeResponseValue;
12348 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12350 export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
12351 if(!isWasmInitialized) {
12352 throw new Error("initializeWasm() must be awaited first!");
12354 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
12355 return nativeResponseValue;
12357 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
12359 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: number): boolean {
12360 if(!isWasmInitialized) {
12361 throw new Error("initializeWasm() must be awaited first!");
12363 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
12364 return nativeResponseValue;
12366 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
12368 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
12369 if(!isWasmInitialized) {
12370 throw new Error("initializeWasm() must be awaited first!");
12372 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
12373 // debug statements here
12375 // uintptr_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
12377 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: number): number {
12378 if(!isWasmInitialized) {
12379 throw new Error("initializeWasm() must be awaited first!");
12381 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
12382 return nativeResponseValue;
12384 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
12386 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
12387 if(!isWasmInitialized) {
12388 throw new Error("initializeWasm() must be awaited first!");
12390 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
12391 return nativeResponseValue;
12393 // uintptr_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
12395 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: number): number {
12396 if(!isWasmInitialized) {
12397 throw new Error("initializeWasm() must be awaited first!");
12399 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
12400 return nativeResponseValue;
12402 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
12404 export function C2Tuple_OutPointScriptZ_clone(orig: number): number {
12405 if(!isWasmInitialized) {
12406 throw new Error("initializeWasm() must be awaited first!");
12408 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
12409 return nativeResponseValue;
12411 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
12413 export function C2Tuple_OutPointScriptZ_new(a: number, b: number): number {
12414 if(!isWasmInitialized) {
12415 throw new Error("initializeWasm() must be awaited first!");
12417 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
12418 return nativeResponseValue;
12420 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
12422 export function C2Tuple_OutPointScriptZ_free(_res: number): void {
12423 if(!isWasmInitialized) {
12424 throw new Error("initializeWasm() must be awaited first!");
12426 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
12427 // debug statements here
12429 // uintptr_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
12431 export function C2Tuple_u32ScriptZ_clone_ptr(arg: number): number {
12432 if(!isWasmInitialized) {
12433 throw new Error("initializeWasm() must be awaited first!");
12435 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
12436 return nativeResponseValue;
12438 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
12440 export function C2Tuple_u32ScriptZ_clone(orig: number): number {
12441 if(!isWasmInitialized) {
12442 throw new Error("initializeWasm() must be awaited first!");
12444 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
12445 return nativeResponseValue;
12447 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
12449 export function C2Tuple_u32ScriptZ_new(a: number, b: number): number {
12450 if(!isWasmInitialized) {
12451 throw new Error("initializeWasm() must be awaited first!");
12453 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
12454 return nativeResponseValue;
12456 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
12458 export function C2Tuple_u32ScriptZ_free(_res: number): void {
12459 if(!isWasmInitialized) {
12460 throw new Error("initializeWasm() must be awaited first!");
12462 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
12463 // debug statements here
12465 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
12467 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
12468 if(!isWasmInitialized) {
12469 throw new Error("initializeWasm() must be awaited first!");
12471 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
12472 // debug statements here
12474 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
12476 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: number): number {
12477 if(!isWasmInitialized) {
12478 throw new Error("initializeWasm() must be awaited first!");
12480 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
12481 return nativeResponseValue;
12483 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
12485 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: number): number {
12486 if(!isWasmInitialized) {
12487 throw new Error("initializeWasm() must be awaited first!");
12489 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
12490 return nativeResponseValue;
12492 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
12494 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): number {
12495 if(!isWasmInitialized) {
12496 throw new Error("initializeWasm() must be awaited first!");
12498 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
12499 return nativeResponseValue;
12501 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
12503 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: number): void {
12504 if(!isWasmInitialized) {
12505 throw new Error("initializeWasm() must be awaited first!");
12507 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
12508 // debug statements here
12510 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
12512 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
12513 if(!isWasmInitialized) {
12514 throw new Error("initializeWasm() must be awaited first!");
12516 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
12517 // debug statements here
12519 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
12521 export function CVec_EventZ_free(_res: number): void {
12522 if(!isWasmInitialized) {
12523 throw new Error("initializeWasm() must be awaited first!");
12525 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
12526 // debug statements here
12528 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
12530 export function CVec_TransactionZ_free(_res: number): void {
12531 if(!isWasmInitialized) {
12532 throw new Error("initializeWasm() must be awaited first!");
12534 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
12535 // debug statements here
12537 // uintptr_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
12539 export function C2Tuple_u32TxOutZ_clone_ptr(arg: number): number {
12540 if(!isWasmInitialized) {
12541 throw new Error("initializeWasm() must be awaited first!");
12543 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
12544 return nativeResponseValue;
12546 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
12548 export function C2Tuple_u32TxOutZ_clone(orig: number): number {
12549 if(!isWasmInitialized) {
12550 throw new Error("initializeWasm() must be awaited first!");
12552 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
12553 return nativeResponseValue;
12555 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
12557 export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
12558 if(!isWasmInitialized) {
12559 throw new Error("initializeWasm() must be awaited first!");
12561 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
12562 return nativeResponseValue;
12564 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
12566 export function C2Tuple_u32TxOutZ_free(_res: number): void {
12567 if(!isWasmInitialized) {
12568 throw new Error("initializeWasm() must be awaited first!");
12570 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
12571 // debug statements here
12573 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
12575 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
12576 if(!isWasmInitialized) {
12577 throw new Error("initializeWasm() must be awaited first!");
12579 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
12580 // debug statements here
12582 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
12584 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: number): number {
12585 if(!isWasmInitialized) {
12586 throw new Error("initializeWasm() must be awaited first!");
12588 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
12589 return nativeResponseValue;
12591 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
12593 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: number): number {
12594 if(!isWasmInitialized) {
12595 throw new Error("initializeWasm() must be awaited first!");
12597 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
12598 return nativeResponseValue;
12600 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
12602 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): number {
12603 if(!isWasmInitialized) {
12604 throw new Error("initializeWasm() must be awaited first!");
12606 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
12607 return nativeResponseValue;
12609 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
12611 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
12612 if(!isWasmInitialized) {
12613 throw new Error("initializeWasm() must be awaited first!");
12615 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
12616 // debug statements here
12618 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
12620 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
12621 if(!isWasmInitialized) {
12622 throw new Error("initializeWasm() must be awaited first!");
12624 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
12625 // debug statements here
12627 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
12629 export function CVec_BalanceZ_free(_res: number): void {
12630 if(!isWasmInitialized) {
12631 throw new Error("initializeWasm() must be awaited first!");
12633 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
12634 // debug statements here
12636 // uintptr_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
12638 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: number): number {
12639 if(!isWasmInitialized) {
12640 throw new Error("initializeWasm() must be awaited first!");
12642 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
12643 return nativeResponseValue;
12645 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
12647 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
12648 if(!isWasmInitialized) {
12649 throw new Error("initializeWasm() must be awaited first!");
12651 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
12652 return nativeResponseValue;
12654 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
12656 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: number): number {
12657 if(!isWasmInitialized) {
12658 throw new Error("initializeWasm() must be awaited first!");
12660 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
12661 return nativeResponseValue;
12663 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
12665 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
12666 if(!isWasmInitialized) {
12667 throw new Error("initializeWasm() must be awaited first!");
12669 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
12670 // debug statements here
12672 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
12674 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
12675 if(!isWasmInitialized) {
12676 throw new Error("initializeWasm() must be awaited first!");
12678 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
12679 return nativeResponseValue;
12681 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
12683 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
12684 if(!isWasmInitialized) {
12685 throw new Error("initializeWasm() must be awaited first!");
12687 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
12688 return nativeResponseValue;
12690 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
12692 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: number): boolean {
12693 if(!isWasmInitialized) {
12694 throw new Error("initializeWasm() must be awaited first!");
12696 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
12697 return nativeResponseValue;
12699 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
12701 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
12702 if(!isWasmInitialized) {
12703 throw new Error("initializeWasm() must be awaited first!");
12705 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
12706 // debug statements here
12708 // uintptr_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
12710 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: number): number {
12711 if(!isWasmInitialized) {
12712 throw new Error("initializeWasm() must be awaited first!");
12714 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
12715 return nativeResponseValue;
12717 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
12719 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
12720 if(!isWasmInitialized) {
12721 throw new Error("initializeWasm() must be awaited first!");
12723 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
12724 return nativeResponseValue;
12726 // uintptr_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
12728 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: number): number {
12729 if(!isWasmInitialized) {
12730 throw new Error("initializeWasm() must be awaited first!");
12732 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
12733 return nativeResponseValue;
12735 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
12737 export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
12738 if(!isWasmInitialized) {
12739 throw new Error("initializeWasm() must be awaited first!");
12741 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
12742 return nativeResponseValue;
12744 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
12746 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: number): number {
12747 if(!isWasmInitialized) {
12748 throw new Error("initializeWasm() must be awaited first!");
12750 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
12751 return nativeResponseValue;
12753 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
12755 export function C2Tuple_PublicKeyTypeZ_free(_res: number): void {
12756 if(!isWasmInitialized) {
12757 throw new Error("initializeWasm() must be awaited first!");
12759 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
12760 // debug statements here
12762 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
12764 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
12765 if(!isWasmInitialized) {
12766 throw new Error("initializeWasm() must be awaited first!");
12768 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
12769 // debug statements here
12771 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
12773 export function COption_NetAddressZ_some(o: number): number {
12774 if(!isWasmInitialized) {
12775 throw new Error("initializeWasm() must be awaited first!");
12777 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
12778 return nativeResponseValue;
12780 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
12782 export function COption_NetAddressZ_none(): number {
12783 if(!isWasmInitialized) {
12784 throw new Error("initializeWasm() must be awaited first!");
12786 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
12787 return nativeResponseValue;
12789 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
12791 export function COption_NetAddressZ_free(_res: number): void {
12792 if(!isWasmInitialized) {
12793 throw new Error("initializeWasm() must be awaited first!");
12795 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
12796 // debug statements here
12798 // uintptr_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
12800 export function COption_NetAddressZ_clone_ptr(arg: number): number {
12801 if(!isWasmInitialized) {
12802 throw new Error("initializeWasm() must be awaited first!");
12804 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
12805 return nativeResponseValue;
12807 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
12809 export function COption_NetAddressZ_clone(orig: number): number {
12810 if(!isWasmInitialized) {
12811 throw new Error("initializeWasm() must be awaited first!");
12813 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
12814 return nativeResponseValue;
12816 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
12818 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): number {
12819 if(!isWasmInitialized) {
12820 throw new Error("initializeWasm() must be awaited first!");
12822 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
12823 return nativeResponseValue;
12825 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
12827 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
12828 if(!isWasmInitialized) {
12829 throw new Error("initializeWasm() must be awaited first!");
12831 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
12832 return nativeResponseValue;
12834 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
12836 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: number): boolean {
12837 if(!isWasmInitialized) {
12838 throw new Error("initializeWasm() must be awaited first!");
12840 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
12841 return nativeResponseValue;
12843 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
12845 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
12846 if(!isWasmInitialized) {
12847 throw new Error("initializeWasm() must be awaited first!");
12849 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
12850 // debug statements here
12852 // uintptr_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
12854 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: number): number {
12855 if(!isWasmInitialized) {
12856 throw new Error("initializeWasm() must be awaited first!");
12858 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
12859 return nativeResponseValue;
12861 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
12863 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
12864 if(!isWasmInitialized) {
12865 throw new Error("initializeWasm() must be awaited first!");
12867 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
12868 return nativeResponseValue;
12870 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
12872 export function CResult_NonePeerHandleErrorZ_ok(): number {
12873 if(!isWasmInitialized) {
12874 throw new Error("initializeWasm() must be awaited first!");
12876 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
12877 return nativeResponseValue;
12879 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
12881 export function CResult_NonePeerHandleErrorZ_err(e: number): number {
12882 if(!isWasmInitialized) {
12883 throw new Error("initializeWasm() must be awaited first!");
12885 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
12886 return nativeResponseValue;
12888 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
12890 export function CResult_NonePeerHandleErrorZ_is_ok(o: number): boolean {
12891 if(!isWasmInitialized) {
12892 throw new Error("initializeWasm() must be awaited first!");
12894 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
12895 return nativeResponseValue;
12897 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
12899 export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
12900 if(!isWasmInitialized) {
12901 throw new Error("initializeWasm() must be awaited first!");
12903 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
12904 // debug statements here
12906 // uintptr_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
12908 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: number): number {
12909 if(!isWasmInitialized) {
12910 throw new Error("initializeWasm() must be awaited first!");
12912 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
12913 return nativeResponseValue;
12915 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
12917 export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
12918 if(!isWasmInitialized) {
12919 throw new Error("initializeWasm() must be awaited first!");
12921 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
12922 return nativeResponseValue;
12924 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
12926 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
12927 if(!isWasmInitialized) {
12928 throw new Error("initializeWasm() must be awaited first!");
12930 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
12931 return nativeResponseValue;
12933 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
12935 export function CResult_boolPeerHandleErrorZ_err(e: number): number {
12936 if(!isWasmInitialized) {
12937 throw new Error("initializeWasm() must be awaited first!");
12939 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
12940 return nativeResponseValue;
12942 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
12944 export function CResult_boolPeerHandleErrorZ_is_ok(o: number): boolean {
12945 if(!isWasmInitialized) {
12946 throw new Error("initializeWasm() must be awaited first!");
12948 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
12949 return nativeResponseValue;
12951 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
12953 export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
12954 if(!isWasmInitialized) {
12955 throw new Error("initializeWasm() must be awaited first!");
12957 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
12958 // debug statements here
12960 // uintptr_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
12962 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: number): number {
12963 if(!isWasmInitialized) {
12964 throw new Error("initializeWasm() must be awaited first!");
12966 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
12967 return nativeResponseValue;
12969 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
12971 export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
12972 if(!isWasmInitialized) {
12973 throw new Error("initializeWasm() must be awaited first!");
12975 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
12976 return nativeResponseValue;
12978 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
12980 export function CResult_NoneErrorZ_ok(): number {
12981 if(!isWasmInitialized) {
12982 throw new Error("initializeWasm() must be awaited first!");
12984 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
12985 return nativeResponseValue;
12987 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
12989 export function CResult_NoneErrorZ_err(e: IOError): number {
12990 if(!isWasmInitialized) {
12991 throw new Error("initializeWasm() must be awaited first!");
12993 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
12994 return nativeResponseValue;
12996 // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
12998 export function CResult_NoneErrorZ_is_ok(o: number): boolean {
12999 if(!isWasmInitialized) {
13000 throw new Error("initializeWasm() must be awaited first!");
13002 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
13003 return nativeResponseValue;
13005 // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
13007 export function CResult_NoneErrorZ_free(_res: number): void {
13008 if(!isWasmInitialized) {
13009 throw new Error("initializeWasm() must be awaited first!");
13011 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
13012 // debug statements here
13014 // uintptr_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
13016 export function CResult_NoneErrorZ_clone_ptr(arg: number): number {
13017 if(!isWasmInitialized) {
13018 throw new Error("initializeWasm() must be awaited first!");
13020 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
13021 return nativeResponseValue;
13023 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
13025 export function CResult_NoneErrorZ_clone(orig: number): number {
13026 if(!isWasmInitialized) {
13027 throw new Error("initializeWasm() must be awaited first!");
13029 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
13030 return nativeResponseValue;
13032 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
13034 export function CResult_NetAddressDecodeErrorZ_ok(o: number): number {
13035 if(!isWasmInitialized) {
13036 throw new Error("initializeWasm() must be awaited first!");
13038 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
13039 return nativeResponseValue;
13041 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
13043 export function CResult_NetAddressDecodeErrorZ_err(e: number): number {
13044 if(!isWasmInitialized) {
13045 throw new Error("initializeWasm() must be awaited first!");
13047 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
13048 return nativeResponseValue;
13050 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
13052 export function CResult_NetAddressDecodeErrorZ_is_ok(o: number): boolean {
13053 if(!isWasmInitialized) {
13054 throw new Error("initializeWasm() must be awaited first!");
13056 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
13057 return nativeResponseValue;
13059 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
13061 export function CResult_NetAddressDecodeErrorZ_free(_res: number): void {
13062 if(!isWasmInitialized) {
13063 throw new Error("initializeWasm() must be awaited first!");
13065 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
13066 // debug statements here
13068 // uintptr_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
13070 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: number): number {
13071 if(!isWasmInitialized) {
13072 throw new Error("initializeWasm() must be awaited first!");
13074 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
13075 return nativeResponseValue;
13077 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
13079 export function CResult_NetAddressDecodeErrorZ_clone(orig: number): number {
13080 if(!isWasmInitialized) {
13081 throw new Error("initializeWasm() must be awaited first!");
13083 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
13084 return nativeResponseValue;
13086 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
13088 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
13089 if(!isWasmInitialized) {
13090 throw new Error("initializeWasm() must be awaited first!");
13092 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
13093 // debug statements here
13095 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
13097 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
13098 if(!isWasmInitialized) {
13099 throw new Error("initializeWasm() must be awaited first!");
13101 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
13102 // debug statements here
13104 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
13106 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
13107 if(!isWasmInitialized) {
13108 throw new Error("initializeWasm() must be awaited first!");
13110 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
13111 // debug statements here
13113 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
13115 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
13116 if(!isWasmInitialized) {
13117 throw new Error("initializeWasm() must be awaited first!");
13119 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
13120 // debug statements here
13122 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
13124 export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
13125 if(!isWasmInitialized) {
13126 throw new Error("initializeWasm() must be awaited first!");
13128 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
13129 return nativeResponseValue;
13131 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
13133 export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
13134 if(!isWasmInitialized) {
13135 throw new Error("initializeWasm() must be awaited first!");
13137 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
13138 return nativeResponseValue;
13140 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
13142 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: number): boolean {
13143 if(!isWasmInitialized) {
13144 throw new Error("initializeWasm() must be awaited first!");
13146 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
13147 return nativeResponseValue;
13149 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
13151 export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
13152 if(!isWasmInitialized) {
13153 throw new Error("initializeWasm() must be awaited first!");
13155 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
13156 // debug statements here
13158 // uintptr_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
13160 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: number): number {
13161 if(!isWasmInitialized) {
13162 throw new Error("initializeWasm() must be awaited first!");
13164 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
13165 return nativeResponseValue;
13167 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
13169 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
13170 if(!isWasmInitialized) {
13171 throw new Error("initializeWasm() must be awaited first!");
13173 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
13174 return nativeResponseValue;
13176 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
13178 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
13179 if(!isWasmInitialized) {
13180 throw new Error("initializeWasm() must be awaited first!");
13182 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
13183 return nativeResponseValue;
13185 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
13187 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
13188 if(!isWasmInitialized) {
13189 throw new Error("initializeWasm() must be awaited first!");
13191 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
13192 return nativeResponseValue;
13194 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
13196 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: number): boolean {
13197 if(!isWasmInitialized) {
13198 throw new Error("initializeWasm() must be awaited first!");
13200 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
13201 return nativeResponseValue;
13203 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
13205 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
13206 if(!isWasmInitialized) {
13207 throw new Error("initializeWasm() must be awaited first!");
13209 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
13210 // debug statements here
13212 // uintptr_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
13214 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: number): number {
13215 if(!isWasmInitialized) {
13216 throw new Error("initializeWasm() must be awaited first!");
13218 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
13219 return nativeResponseValue;
13221 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
13223 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
13224 if(!isWasmInitialized) {
13225 throw new Error("initializeWasm() must be awaited first!");
13227 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
13228 return nativeResponseValue;
13230 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
13232 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
13233 if(!isWasmInitialized) {
13234 throw new Error("initializeWasm() must be awaited first!");
13236 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
13237 return nativeResponseValue;
13239 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
13241 export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
13242 if(!isWasmInitialized) {
13243 throw new Error("initializeWasm() must be awaited first!");
13245 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
13246 return nativeResponseValue;
13248 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
13250 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: number): boolean {
13251 if(!isWasmInitialized) {
13252 throw new Error("initializeWasm() must be awaited first!");
13254 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
13255 return nativeResponseValue;
13257 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
13259 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
13260 if(!isWasmInitialized) {
13261 throw new Error("initializeWasm() must be awaited first!");
13263 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
13264 // debug statements here
13266 // uintptr_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
13268 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: number): number {
13269 if(!isWasmInitialized) {
13270 throw new Error("initializeWasm() must be awaited first!");
13272 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
13273 return nativeResponseValue;
13275 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
13277 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
13278 if(!isWasmInitialized) {
13279 throw new Error("initializeWasm() must be awaited first!");
13281 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
13282 return nativeResponseValue;
13284 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
13286 export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
13287 if(!isWasmInitialized) {
13288 throw new Error("initializeWasm() must be awaited first!");
13290 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
13291 return nativeResponseValue;
13293 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13295 export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
13296 if(!isWasmInitialized) {
13297 throw new Error("initializeWasm() must be awaited first!");
13299 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
13300 return nativeResponseValue;
13302 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
13304 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: number): boolean {
13305 if(!isWasmInitialized) {
13306 throw new Error("initializeWasm() must be awaited first!");
13308 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
13309 return nativeResponseValue;
13311 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
13313 export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
13314 if(!isWasmInitialized) {
13315 throw new Error("initializeWasm() must be awaited first!");
13317 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
13318 // debug statements here
13320 // uintptr_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
13322 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: number): number {
13323 if(!isWasmInitialized) {
13324 throw new Error("initializeWasm() must be awaited first!");
13326 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
13327 return nativeResponseValue;
13329 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
13331 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
13332 if(!isWasmInitialized) {
13333 throw new Error("initializeWasm() must be awaited first!");
13335 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
13336 return nativeResponseValue;
13338 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
13340 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: number): number {
13341 if(!isWasmInitialized) {
13342 throw new Error("initializeWasm() must be awaited first!");
13344 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
13345 return nativeResponseValue;
13347 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
13349 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: number): number {
13350 if(!isWasmInitialized) {
13351 throw new Error("initializeWasm() must be awaited first!");
13353 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
13354 return nativeResponseValue;
13356 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
13358 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: number): boolean {
13359 if(!isWasmInitialized) {
13360 throw new Error("initializeWasm() must be awaited first!");
13362 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
13363 return nativeResponseValue;
13365 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
13367 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
13368 if(!isWasmInitialized) {
13369 throw new Error("initializeWasm() must be awaited first!");
13371 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
13372 // debug statements here
13374 // uintptr_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
13376 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: number): number {
13377 if(!isWasmInitialized) {
13378 throw new Error("initializeWasm() must be awaited first!");
13380 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
13381 return nativeResponseValue;
13383 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
13385 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
13386 if(!isWasmInitialized) {
13387 throw new Error("initializeWasm() must be awaited first!");
13389 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
13390 return nativeResponseValue;
13392 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
13394 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
13395 if(!isWasmInitialized) {
13396 throw new Error("initializeWasm() must be awaited first!");
13398 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
13399 return nativeResponseValue;
13401 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
13403 export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
13404 if(!isWasmInitialized) {
13405 throw new Error("initializeWasm() must be awaited first!");
13407 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
13408 return nativeResponseValue;
13410 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
13412 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: number): boolean {
13413 if(!isWasmInitialized) {
13414 throw new Error("initializeWasm() must be awaited first!");
13416 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
13417 return nativeResponseValue;
13419 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
13421 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
13422 if(!isWasmInitialized) {
13423 throw new Error("initializeWasm() must be awaited first!");
13425 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
13426 // debug statements here
13428 // uintptr_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
13430 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: number): number {
13431 if(!isWasmInitialized) {
13432 throw new Error("initializeWasm() must be awaited first!");
13434 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
13435 return nativeResponseValue;
13437 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
13439 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
13440 if(!isWasmInitialized) {
13441 throw new Error("initializeWasm() must be awaited first!");
13443 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
13444 return nativeResponseValue;
13446 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
13448 export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
13449 if(!isWasmInitialized) {
13450 throw new Error("initializeWasm() must be awaited first!");
13452 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
13453 return nativeResponseValue;
13455 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
13457 export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
13458 if(!isWasmInitialized) {
13459 throw new Error("initializeWasm() must be awaited first!");
13461 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
13462 return nativeResponseValue;
13464 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
13466 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: number): boolean {
13467 if(!isWasmInitialized) {
13468 throw new Error("initializeWasm() must be awaited first!");
13470 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
13471 return nativeResponseValue;
13473 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
13475 export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
13476 if(!isWasmInitialized) {
13477 throw new Error("initializeWasm() must be awaited first!");
13479 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
13480 // debug statements here
13482 // uintptr_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
13484 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: number): number {
13485 if(!isWasmInitialized) {
13486 throw new Error("initializeWasm() must be awaited first!");
13488 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
13489 return nativeResponseValue;
13491 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
13493 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
13494 if(!isWasmInitialized) {
13495 throw new Error("initializeWasm() must be awaited first!");
13497 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
13498 return nativeResponseValue;
13500 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
13502 export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
13503 if(!isWasmInitialized) {
13504 throw new Error("initializeWasm() must be awaited first!");
13506 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
13507 return nativeResponseValue;
13509 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13511 export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
13512 if(!isWasmInitialized) {
13513 throw new Error("initializeWasm() must be awaited first!");
13515 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
13516 return nativeResponseValue;
13518 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
13520 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: number): boolean {
13521 if(!isWasmInitialized) {
13522 throw new Error("initializeWasm() must be awaited first!");
13524 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
13525 return nativeResponseValue;
13527 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
13529 export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
13530 if(!isWasmInitialized) {
13531 throw new Error("initializeWasm() must be awaited first!");
13533 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
13534 // debug statements here
13536 // uintptr_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
13538 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: number): number {
13539 if(!isWasmInitialized) {
13540 throw new Error("initializeWasm() must be awaited first!");
13542 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
13543 return nativeResponseValue;
13545 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
13547 export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
13548 if(!isWasmInitialized) {
13549 throw new Error("initializeWasm() must be awaited first!");
13551 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
13552 return nativeResponseValue;
13554 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
13556 export function CResult_ChannelReadyDecodeErrorZ_ok(o: number): number {
13557 if(!isWasmInitialized) {
13558 throw new Error("initializeWasm() must be awaited first!");
13560 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
13561 return nativeResponseValue;
13563 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
13565 export function CResult_ChannelReadyDecodeErrorZ_err(e: number): number {
13566 if(!isWasmInitialized) {
13567 throw new Error("initializeWasm() must be awaited first!");
13569 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
13570 return nativeResponseValue;
13572 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
13574 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: number): boolean {
13575 if(!isWasmInitialized) {
13576 throw new Error("initializeWasm() must be awaited first!");
13578 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
13579 return nativeResponseValue;
13581 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
13583 export function CResult_ChannelReadyDecodeErrorZ_free(_res: number): void {
13584 if(!isWasmInitialized) {
13585 throw new Error("initializeWasm() must be awaited first!");
13587 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
13588 // debug statements here
13590 // uintptr_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
13592 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: number): number {
13593 if(!isWasmInitialized) {
13594 throw new Error("initializeWasm() must be awaited first!");
13596 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
13597 return nativeResponseValue;
13599 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
13601 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: number): number {
13602 if(!isWasmInitialized) {
13603 throw new Error("initializeWasm() must be awaited first!");
13605 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
13606 return nativeResponseValue;
13608 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
13610 export function CResult_InitDecodeErrorZ_ok(o: number): number {
13611 if(!isWasmInitialized) {
13612 throw new Error("initializeWasm() must be awaited first!");
13614 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
13615 return nativeResponseValue;
13617 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
13619 export function CResult_InitDecodeErrorZ_err(e: number): number {
13620 if(!isWasmInitialized) {
13621 throw new Error("initializeWasm() must be awaited first!");
13623 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
13624 return nativeResponseValue;
13626 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
13628 export function CResult_InitDecodeErrorZ_is_ok(o: number): boolean {
13629 if(!isWasmInitialized) {
13630 throw new Error("initializeWasm() must be awaited first!");
13632 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
13633 return nativeResponseValue;
13635 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
13637 export function CResult_InitDecodeErrorZ_free(_res: number): void {
13638 if(!isWasmInitialized) {
13639 throw new Error("initializeWasm() must be awaited first!");
13641 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
13642 // debug statements here
13644 // uintptr_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
13646 export function CResult_InitDecodeErrorZ_clone_ptr(arg: number): number {
13647 if(!isWasmInitialized) {
13648 throw new Error("initializeWasm() must be awaited first!");
13650 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
13651 return nativeResponseValue;
13653 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
13655 export function CResult_InitDecodeErrorZ_clone(orig: number): number {
13656 if(!isWasmInitialized) {
13657 throw new Error("initializeWasm() must be awaited first!");
13659 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
13660 return nativeResponseValue;
13662 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
13664 export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
13665 if(!isWasmInitialized) {
13666 throw new Error("initializeWasm() must be awaited first!");
13668 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
13669 return nativeResponseValue;
13671 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
13673 export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
13674 if(!isWasmInitialized) {
13675 throw new Error("initializeWasm() must be awaited first!");
13677 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
13678 return nativeResponseValue;
13680 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
13682 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: number): boolean {
13683 if(!isWasmInitialized) {
13684 throw new Error("initializeWasm() must be awaited first!");
13686 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
13687 return nativeResponseValue;
13689 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
13691 export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
13692 if(!isWasmInitialized) {
13693 throw new Error("initializeWasm() must be awaited first!");
13695 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
13696 // debug statements here
13698 // uintptr_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
13700 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: number): number {
13701 if(!isWasmInitialized) {
13702 throw new Error("initializeWasm() must be awaited first!");
13704 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
13705 return nativeResponseValue;
13707 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
13709 export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
13710 if(!isWasmInitialized) {
13711 throw new Error("initializeWasm() must be awaited first!");
13713 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
13714 return nativeResponseValue;
13716 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
13718 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
13719 if(!isWasmInitialized) {
13720 throw new Error("initializeWasm() must be awaited first!");
13722 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
13723 return nativeResponseValue;
13725 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
13727 export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
13728 if(!isWasmInitialized) {
13729 throw new Error("initializeWasm() must be awaited first!");
13731 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
13732 return nativeResponseValue;
13734 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
13736 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: number): boolean {
13737 if(!isWasmInitialized) {
13738 throw new Error("initializeWasm() must be awaited first!");
13740 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
13741 return nativeResponseValue;
13743 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
13745 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
13746 if(!isWasmInitialized) {
13747 throw new Error("initializeWasm() must be awaited first!");
13749 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
13750 // debug statements here
13752 // uintptr_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
13754 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: number): number {
13755 if(!isWasmInitialized) {
13756 throw new Error("initializeWasm() must be awaited first!");
13758 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
13759 return nativeResponseValue;
13761 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
13763 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
13764 if(!isWasmInitialized) {
13765 throw new Error("initializeWasm() must be awaited first!");
13767 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
13768 return nativeResponseValue;
13770 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
13772 export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
13773 if(!isWasmInitialized) {
13774 throw new Error("initializeWasm() must be awaited first!");
13776 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
13777 return nativeResponseValue;
13779 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
13781 export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
13782 if(!isWasmInitialized) {
13783 throw new Error("initializeWasm() must be awaited first!");
13785 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
13786 return nativeResponseValue;
13788 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
13790 export function CResult_ShutdownDecodeErrorZ_is_ok(o: number): boolean {
13791 if(!isWasmInitialized) {
13792 throw new Error("initializeWasm() must be awaited first!");
13794 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
13795 return nativeResponseValue;
13797 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
13799 export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
13800 if(!isWasmInitialized) {
13801 throw new Error("initializeWasm() must be awaited first!");
13803 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
13804 // debug statements here
13806 // uintptr_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
13808 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: number): number {
13809 if(!isWasmInitialized) {
13810 throw new Error("initializeWasm() must be awaited first!");
13812 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
13813 return nativeResponseValue;
13815 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
13817 export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
13818 if(!isWasmInitialized) {
13819 throw new Error("initializeWasm() must be awaited first!");
13821 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
13822 return nativeResponseValue;
13824 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
13826 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
13827 if(!isWasmInitialized) {
13828 throw new Error("initializeWasm() must be awaited first!");
13830 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
13831 return nativeResponseValue;
13833 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13835 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
13836 if(!isWasmInitialized) {
13837 throw new Error("initializeWasm() must be awaited first!");
13839 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
13840 return nativeResponseValue;
13842 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
13844 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: number): boolean {
13845 if(!isWasmInitialized) {
13846 throw new Error("initializeWasm() must be awaited first!");
13848 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
13849 return nativeResponseValue;
13851 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
13853 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
13854 if(!isWasmInitialized) {
13855 throw new Error("initializeWasm() must be awaited first!");
13857 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
13858 // debug statements here
13860 // uintptr_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
13862 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13863 if(!isWasmInitialized) {
13864 throw new Error("initializeWasm() must be awaited first!");
13866 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
13867 return nativeResponseValue;
13869 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
13871 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
13872 if(!isWasmInitialized) {
13873 throw new Error("initializeWasm() must be awaited first!");
13875 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
13876 return nativeResponseValue;
13878 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
13880 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
13881 if(!isWasmInitialized) {
13882 throw new Error("initializeWasm() must be awaited first!");
13884 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
13885 return nativeResponseValue;
13887 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13889 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
13890 if(!isWasmInitialized) {
13891 throw new Error("initializeWasm() must be awaited first!");
13893 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
13894 return nativeResponseValue;
13896 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
13898 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: number): boolean {
13899 if(!isWasmInitialized) {
13900 throw new Error("initializeWasm() must be awaited first!");
13902 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
13903 return nativeResponseValue;
13905 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
13907 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
13908 if(!isWasmInitialized) {
13909 throw new Error("initializeWasm() must be awaited first!");
13911 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
13912 // debug statements here
13914 // uintptr_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
13916 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: number): number {
13917 if(!isWasmInitialized) {
13918 throw new Error("initializeWasm() must be awaited first!");
13920 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
13921 return nativeResponseValue;
13923 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
13925 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
13926 if(!isWasmInitialized) {
13927 throw new Error("initializeWasm() must be awaited first!");
13929 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
13930 return nativeResponseValue;
13932 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
13934 export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
13935 if(!isWasmInitialized) {
13936 throw new Error("initializeWasm() must be awaited first!");
13938 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
13939 return nativeResponseValue;
13941 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
13943 export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
13944 if(!isWasmInitialized) {
13945 throw new Error("initializeWasm() must be awaited first!");
13947 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
13948 return nativeResponseValue;
13950 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
13952 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: number): boolean {
13953 if(!isWasmInitialized) {
13954 throw new Error("initializeWasm() must be awaited first!");
13956 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
13957 return nativeResponseValue;
13959 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
13961 export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
13962 if(!isWasmInitialized) {
13963 throw new Error("initializeWasm() must be awaited first!");
13965 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
13966 // debug statements here
13968 // uintptr_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
13970 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: number): number {
13971 if(!isWasmInitialized) {
13972 throw new Error("initializeWasm() must be awaited first!");
13974 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
13975 return nativeResponseValue;
13977 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
13979 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
13980 if(!isWasmInitialized) {
13981 throw new Error("initializeWasm() must be awaited first!");
13983 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
13984 return nativeResponseValue;
13986 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
13988 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
13989 if(!isWasmInitialized) {
13990 throw new Error("initializeWasm() must be awaited first!");
13992 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
13993 return nativeResponseValue;
13995 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
13997 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
13998 if(!isWasmInitialized) {
13999 throw new Error("initializeWasm() must be awaited first!");
14001 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
14002 return nativeResponseValue;
14004 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
14006 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: number): boolean {
14007 if(!isWasmInitialized) {
14008 throw new Error("initializeWasm() must be awaited first!");
14010 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
14011 return nativeResponseValue;
14013 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
14015 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
14016 if(!isWasmInitialized) {
14017 throw new Error("initializeWasm() must be awaited first!");
14019 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
14020 // debug statements here
14022 // uintptr_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
14024 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14025 if(!isWasmInitialized) {
14026 throw new Error("initializeWasm() must be awaited first!");
14028 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
14029 return nativeResponseValue;
14031 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
14033 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
14034 if(!isWasmInitialized) {
14035 throw new Error("initializeWasm() must be awaited first!");
14037 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
14038 return nativeResponseValue;
14040 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
14042 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
14043 if(!isWasmInitialized) {
14044 throw new Error("initializeWasm() must be awaited first!");
14046 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
14047 return nativeResponseValue;
14049 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14051 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
14052 if(!isWasmInitialized) {
14053 throw new Error("initializeWasm() must be awaited first!");
14055 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
14056 return nativeResponseValue;
14058 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
14060 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: number): boolean {
14061 if(!isWasmInitialized) {
14062 throw new Error("initializeWasm() must be awaited first!");
14064 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
14065 return nativeResponseValue;
14067 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
14069 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
14070 if(!isWasmInitialized) {
14071 throw new Error("initializeWasm() must be awaited first!");
14073 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
14074 // debug statements here
14076 // uintptr_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
14078 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14079 if(!isWasmInitialized) {
14080 throw new Error("initializeWasm() must be awaited first!");
14082 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
14083 return nativeResponseValue;
14085 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
14087 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
14088 if(!isWasmInitialized) {
14089 throw new Error("initializeWasm() must be awaited first!");
14091 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
14092 return nativeResponseValue;
14094 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
14096 export function CResult_PingDecodeErrorZ_ok(o: number): number {
14097 if(!isWasmInitialized) {
14098 throw new Error("initializeWasm() must be awaited first!");
14100 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
14101 return nativeResponseValue;
14103 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
14105 export function CResult_PingDecodeErrorZ_err(e: number): number {
14106 if(!isWasmInitialized) {
14107 throw new Error("initializeWasm() must be awaited first!");
14109 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
14110 return nativeResponseValue;
14112 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
14114 export function CResult_PingDecodeErrorZ_is_ok(o: number): boolean {
14115 if(!isWasmInitialized) {
14116 throw new Error("initializeWasm() must be awaited first!");
14118 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
14119 return nativeResponseValue;
14121 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
14123 export function CResult_PingDecodeErrorZ_free(_res: number): void {
14124 if(!isWasmInitialized) {
14125 throw new Error("initializeWasm() must be awaited first!");
14127 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
14128 // debug statements here
14130 // uintptr_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
14132 export function CResult_PingDecodeErrorZ_clone_ptr(arg: number): number {
14133 if(!isWasmInitialized) {
14134 throw new Error("initializeWasm() must be awaited first!");
14136 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
14137 return nativeResponseValue;
14139 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
14141 export function CResult_PingDecodeErrorZ_clone(orig: number): number {
14142 if(!isWasmInitialized) {
14143 throw new Error("initializeWasm() must be awaited first!");
14145 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
14146 return nativeResponseValue;
14148 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
14150 export function CResult_PongDecodeErrorZ_ok(o: number): number {
14151 if(!isWasmInitialized) {
14152 throw new Error("initializeWasm() must be awaited first!");
14154 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
14155 return nativeResponseValue;
14157 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
14159 export function CResult_PongDecodeErrorZ_err(e: number): number {
14160 if(!isWasmInitialized) {
14161 throw new Error("initializeWasm() must be awaited first!");
14163 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
14164 return nativeResponseValue;
14166 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
14168 export function CResult_PongDecodeErrorZ_is_ok(o: number): boolean {
14169 if(!isWasmInitialized) {
14170 throw new Error("initializeWasm() must be awaited first!");
14172 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
14173 return nativeResponseValue;
14175 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
14177 export function CResult_PongDecodeErrorZ_free(_res: number): void {
14178 if(!isWasmInitialized) {
14179 throw new Error("initializeWasm() must be awaited first!");
14181 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
14182 // debug statements here
14184 // uintptr_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
14186 export function CResult_PongDecodeErrorZ_clone_ptr(arg: number): number {
14187 if(!isWasmInitialized) {
14188 throw new Error("initializeWasm() must be awaited first!");
14190 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
14191 return nativeResponseValue;
14193 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
14195 export function CResult_PongDecodeErrorZ_clone(orig: number): number {
14196 if(!isWasmInitialized) {
14197 throw new Error("initializeWasm() must be awaited first!");
14199 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
14200 return nativeResponseValue;
14202 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
14204 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
14205 if(!isWasmInitialized) {
14206 throw new Error("initializeWasm() must be awaited first!");
14208 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
14209 return nativeResponseValue;
14211 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14213 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
14214 if(!isWasmInitialized) {
14215 throw new Error("initializeWasm() must be awaited first!");
14217 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
14218 return nativeResponseValue;
14220 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14222 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14223 if(!isWasmInitialized) {
14224 throw new Error("initializeWasm() must be awaited first!");
14226 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
14227 return nativeResponseValue;
14229 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
14231 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
14232 if(!isWasmInitialized) {
14233 throw new Error("initializeWasm() must be awaited first!");
14235 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
14236 // debug statements here
14238 // uintptr_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14240 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14241 if(!isWasmInitialized) {
14242 throw new Error("initializeWasm() must be awaited first!");
14244 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14245 return nativeResponseValue;
14247 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14249 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
14250 if(!isWasmInitialized) {
14251 throw new Error("initializeWasm() must be awaited first!");
14253 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
14254 return nativeResponseValue;
14256 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
14258 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
14259 if(!isWasmInitialized) {
14260 throw new Error("initializeWasm() must be awaited first!");
14262 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
14263 return nativeResponseValue;
14265 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14267 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
14268 if(!isWasmInitialized) {
14269 throw new Error("initializeWasm() must be awaited first!");
14271 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
14272 return nativeResponseValue;
14274 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14276 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14277 if(!isWasmInitialized) {
14278 throw new Error("initializeWasm() must be awaited first!");
14280 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
14281 return nativeResponseValue;
14283 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
14285 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
14286 if(!isWasmInitialized) {
14287 throw new Error("initializeWasm() must be awaited first!");
14289 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
14290 // debug statements here
14292 // uintptr_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14294 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14295 if(!isWasmInitialized) {
14296 throw new Error("initializeWasm() must be awaited first!");
14298 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14299 return nativeResponseValue;
14301 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14303 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
14304 if(!isWasmInitialized) {
14305 throw new Error("initializeWasm() must be awaited first!");
14307 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
14308 return nativeResponseValue;
14310 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
14312 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
14313 if(!isWasmInitialized) {
14314 throw new Error("initializeWasm() must be awaited first!");
14316 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
14317 return nativeResponseValue;
14319 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14321 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
14322 if(!isWasmInitialized) {
14323 throw new Error("initializeWasm() must be awaited first!");
14325 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
14326 return nativeResponseValue;
14328 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14330 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14331 if(!isWasmInitialized) {
14332 throw new Error("initializeWasm() must be awaited first!");
14334 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
14335 return nativeResponseValue;
14337 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
14339 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
14340 if(!isWasmInitialized) {
14341 throw new Error("initializeWasm() must be awaited first!");
14343 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
14344 // debug statements here
14346 // uintptr_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14348 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14349 if(!isWasmInitialized) {
14350 throw new Error("initializeWasm() must be awaited first!");
14352 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
14353 return nativeResponseValue;
14355 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14357 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
14358 if(!isWasmInitialized) {
14359 throw new Error("initializeWasm() must be awaited first!");
14361 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
14362 return nativeResponseValue;
14364 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
14366 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
14367 if(!isWasmInitialized) {
14368 throw new Error("initializeWasm() must be awaited first!");
14370 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
14371 return nativeResponseValue;
14373 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14375 export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
14376 if(!isWasmInitialized) {
14377 throw new Error("initializeWasm() must be awaited first!");
14379 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
14380 return nativeResponseValue;
14382 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14384 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14385 if(!isWasmInitialized) {
14386 throw new Error("initializeWasm() must be awaited first!");
14388 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
14389 return nativeResponseValue;
14391 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
14393 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
14394 if(!isWasmInitialized) {
14395 throw new Error("initializeWasm() must be awaited first!");
14397 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
14398 // debug statements here
14400 // uintptr_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14402 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14403 if(!isWasmInitialized) {
14404 throw new Error("initializeWasm() must be awaited first!");
14406 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
14407 return nativeResponseValue;
14409 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14411 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
14412 if(!isWasmInitialized) {
14413 throw new Error("initializeWasm() must be awaited first!");
14415 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
14416 return nativeResponseValue;
14418 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
14420 export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
14421 if(!isWasmInitialized) {
14422 throw new Error("initializeWasm() must be awaited first!");
14424 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
14425 return nativeResponseValue;
14427 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
14429 export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
14430 if(!isWasmInitialized) {
14431 throw new Error("initializeWasm() must be awaited first!");
14433 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
14434 return nativeResponseValue;
14436 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
14438 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: number): boolean {
14439 if(!isWasmInitialized) {
14440 throw new Error("initializeWasm() must be awaited first!");
14442 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
14443 return nativeResponseValue;
14445 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
14447 export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
14448 if(!isWasmInitialized) {
14449 throw new Error("initializeWasm() must be awaited first!");
14451 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
14452 // debug statements here
14454 // uintptr_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
14456 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: number): number {
14457 if(!isWasmInitialized) {
14458 throw new Error("initializeWasm() must be awaited first!");
14460 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
14461 return nativeResponseValue;
14463 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
14465 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
14466 if(!isWasmInitialized) {
14467 throw new Error("initializeWasm() must be awaited first!");
14469 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
14470 return nativeResponseValue;
14472 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
14474 export function CResult_WarningMessageDecodeErrorZ_ok(o: number): number {
14475 if(!isWasmInitialized) {
14476 throw new Error("initializeWasm() must be awaited first!");
14478 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
14479 return nativeResponseValue;
14481 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
14483 export function CResult_WarningMessageDecodeErrorZ_err(e: number): number {
14484 if(!isWasmInitialized) {
14485 throw new Error("initializeWasm() must be awaited first!");
14487 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
14488 return nativeResponseValue;
14490 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
14492 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: number): boolean {
14493 if(!isWasmInitialized) {
14494 throw new Error("initializeWasm() must be awaited first!");
14496 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
14497 return nativeResponseValue;
14499 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
14501 export function CResult_WarningMessageDecodeErrorZ_free(_res: number): void {
14502 if(!isWasmInitialized) {
14503 throw new Error("initializeWasm() must be awaited first!");
14505 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
14506 // debug statements here
14508 // uintptr_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
14510 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: number): number {
14511 if(!isWasmInitialized) {
14512 throw new Error("initializeWasm() must be awaited first!");
14514 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
14515 return nativeResponseValue;
14517 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
14519 export function CResult_WarningMessageDecodeErrorZ_clone(orig: number): number {
14520 if(!isWasmInitialized) {
14521 throw new Error("initializeWasm() must be awaited first!");
14523 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
14524 return nativeResponseValue;
14526 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
14528 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
14529 if(!isWasmInitialized) {
14530 throw new Error("initializeWasm() must be awaited first!");
14532 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
14533 return nativeResponseValue;
14535 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14537 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
14538 if(!isWasmInitialized) {
14539 throw new Error("initializeWasm() must be awaited first!");
14541 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
14542 return nativeResponseValue;
14544 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14546 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14547 if(!isWasmInitialized) {
14548 throw new Error("initializeWasm() must be awaited first!");
14550 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
14551 return nativeResponseValue;
14553 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
14555 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
14556 if(!isWasmInitialized) {
14557 throw new Error("initializeWasm() must be awaited first!");
14559 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
14560 // debug statements here
14562 // uintptr_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14564 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14565 if(!isWasmInitialized) {
14566 throw new Error("initializeWasm() must be awaited first!");
14568 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14569 return nativeResponseValue;
14571 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14573 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14574 if(!isWasmInitialized) {
14575 throw new Error("initializeWasm() must be awaited first!");
14577 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
14578 return nativeResponseValue;
14580 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
14582 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
14583 if(!isWasmInitialized) {
14584 throw new Error("initializeWasm() must be awaited first!");
14586 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
14587 return nativeResponseValue;
14589 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14591 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
14592 if(!isWasmInitialized) {
14593 throw new Error("initializeWasm() must be awaited first!");
14595 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
14596 return nativeResponseValue;
14598 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14600 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14601 if(!isWasmInitialized) {
14602 throw new Error("initializeWasm() must be awaited first!");
14604 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
14605 return nativeResponseValue;
14607 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
14609 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
14610 if(!isWasmInitialized) {
14611 throw new Error("initializeWasm() must be awaited first!");
14613 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
14614 // debug statements here
14616 // uintptr_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14618 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14619 if(!isWasmInitialized) {
14620 throw new Error("initializeWasm() must be awaited first!");
14622 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14623 return nativeResponseValue;
14625 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14627 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14628 if(!isWasmInitialized) {
14629 throw new Error("initializeWasm() must be awaited first!");
14631 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
14632 return nativeResponseValue;
14634 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
14636 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
14637 if(!isWasmInitialized) {
14638 throw new Error("initializeWasm() must be awaited first!");
14640 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
14641 return nativeResponseValue;
14643 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
14645 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
14646 if(!isWasmInitialized) {
14647 throw new Error("initializeWasm() must be awaited first!");
14649 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
14650 return nativeResponseValue;
14652 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
14654 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: number): boolean {
14655 if(!isWasmInitialized) {
14656 throw new Error("initializeWasm() must be awaited first!");
14658 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
14659 return nativeResponseValue;
14661 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
14663 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
14664 if(!isWasmInitialized) {
14665 throw new Error("initializeWasm() must be awaited first!");
14667 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
14668 // debug statements here
14670 // uintptr_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
14672 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: number): number {
14673 if(!isWasmInitialized) {
14674 throw new Error("initializeWasm() must be awaited first!");
14676 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
14677 return nativeResponseValue;
14679 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
14681 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
14682 if(!isWasmInitialized) {
14683 throw new Error("initializeWasm() must be awaited first!");
14685 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
14686 return nativeResponseValue;
14688 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
14690 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
14691 if(!isWasmInitialized) {
14692 throw new Error("initializeWasm() must be awaited first!");
14694 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
14695 return nativeResponseValue;
14697 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
14699 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
14700 if(!isWasmInitialized) {
14701 throw new Error("initializeWasm() must be awaited first!");
14703 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
14704 return nativeResponseValue;
14706 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
14708 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: number): boolean {
14709 if(!isWasmInitialized) {
14710 throw new Error("initializeWasm() must be awaited first!");
14712 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
14713 return nativeResponseValue;
14715 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
14717 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
14718 if(!isWasmInitialized) {
14719 throw new Error("initializeWasm() must be awaited first!");
14721 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
14722 // debug statements here
14724 // uintptr_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
14726 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: number): number {
14727 if(!isWasmInitialized) {
14728 throw new Error("initializeWasm() must be awaited first!");
14730 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
14731 return nativeResponseValue;
14733 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
14735 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
14736 if(!isWasmInitialized) {
14737 throw new Error("initializeWasm() must be awaited first!");
14739 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
14740 return nativeResponseValue;
14742 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
14744 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
14745 if(!isWasmInitialized) {
14746 throw new Error("initializeWasm() must be awaited first!");
14748 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
14749 return nativeResponseValue;
14751 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
14753 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
14754 if(!isWasmInitialized) {
14755 throw new Error("initializeWasm() must be awaited first!");
14757 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
14758 return nativeResponseValue;
14760 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
14762 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
14763 if(!isWasmInitialized) {
14764 throw new Error("initializeWasm() must be awaited first!");
14766 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
14767 return nativeResponseValue;
14769 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
14771 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
14772 if(!isWasmInitialized) {
14773 throw new Error("initializeWasm() must be awaited first!");
14775 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
14776 // debug statements here
14778 // uintptr_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
14780 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
14781 if(!isWasmInitialized) {
14782 throw new Error("initializeWasm() must be awaited first!");
14784 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
14785 return nativeResponseValue;
14787 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
14789 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
14790 if(!isWasmInitialized) {
14791 throw new Error("initializeWasm() must be awaited first!");
14793 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
14794 return nativeResponseValue;
14796 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
14798 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
14799 if(!isWasmInitialized) {
14800 throw new Error("initializeWasm() must be awaited first!");
14802 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
14803 return nativeResponseValue;
14805 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
14807 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
14808 if(!isWasmInitialized) {
14809 throw new Error("initializeWasm() must be awaited first!");
14811 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
14812 return nativeResponseValue;
14814 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
14816 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
14817 if(!isWasmInitialized) {
14818 throw new Error("initializeWasm() must be awaited first!");
14820 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
14821 return nativeResponseValue;
14823 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
14825 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
14826 if(!isWasmInitialized) {
14827 throw new Error("initializeWasm() must be awaited first!");
14829 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
14830 // debug statements here
14832 // uintptr_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
14834 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
14835 if(!isWasmInitialized) {
14836 throw new Error("initializeWasm() must be awaited first!");
14838 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
14839 return nativeResponseValue;
14841 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
14843 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
14844 if(!isWasmInitialized) {
14845 throw new Error("initializeWasm() must be awaited first!");
14847 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
14848 return nativeResponseValue;
14850 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
14852 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
14853 if(!isWasmInitialized) {
14854 throw new Error("initializeWasm() must be awaited first!");
14856 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
14857 return nativeResponseValue;
14859 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
14861 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
14862 if(!isWasmInitialized) {
14863 throw new Error("initializeWasm() must be awaited first!");
14865 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
14866 return nativeResponseValue;
14868 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
14870 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: number): boolean {
14871 if(!isWasmInitialized) {
14872 throw new Error("initializeWasm() must be awaited first!");
14874 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
14875 return nativeResponseValue;
14877 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
14879 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
14880 if(!isWasmInitialized) {
14881 throw new Error("initializeWasm() must be awaited first!");
14883 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
14884 // debug statements here
14886 // uintptr_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
14888 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: number): number {
14889 if(!isWasmInitialized) {
14890 throw new Error("initializeWasm() must be awaited first!");
14892 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
14893 return nativeResponseValue;
14895 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
14897 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
14898 if(!isWasmInitialized) {
14899 throw new Error("initializeWasm() must be awaited first!");
14901 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
14902 return nativeResponseValue;
14904 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
14906 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: number): number {
14907 if(!isWasmInitialized) {
14908 throw new Error("initializeWasm() must be awaited first!");
14910 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
14911 return nativeResponseValue;
14913 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
14915 export function CResult_InvoiceSignOrCreationErrorZ_err(e: number): number {
14916 if(!isWasmInitialized) {
14917 throw new Error("initializeWasm() must be awaited first!");
14919 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
14920 return nativeResponseValue;
14922 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
14924 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: number): boolean {
14925 if(!isWasmInitialized) {
14926 throw new Error("initializeWasm() must be awaited first!");
14928 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
14929 return nativeResponseValue;
14931 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
14933 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: number): void {
14934 if(!isWasmInitialized) {
14935 throw new Error("initializeWasm() must be awaited first!");
14937 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
14938 // debug statements here
14940 // uintptr_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
14942 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: number): number {
14943 if(!isWasmInitialized) {
14944 throw new Error("initializeWasm() must be awaited first!");
14946 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
14947 return nativeResponseValue;
14949 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
14951 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: number): number {
14952 if(!isWasmInitialized) {
14953 throw new Error("initializeWasm() must be awaited first!");
14955 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
14956 return nativeResponseValue;
14958 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
14960 export function COption_FilterZ_some(o: number): number {
14961 if(!isWasmInitialized) {
14962 throw new Error("initializeWasm() must be awaited first!");
14964 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
14965 return nativeResponseValue;
14967 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
14969 export function COption_FilterZ_none(): number {
14970 if(!isWasmInitialized) {
14971 throw new Error("initializeWasm() must be awaited first!");
14973 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
14974 return nativeResponseValue;
14976 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
14978 export function COption_FilterZ_free(_res: number): void {
14979 if(!isWasmInitialized) {
14980 throw new Error("initializeWasm() must be awaited first!");
14982 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
14983 // debug statements here
14985 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
14987 export function CResult_LockedChannelMonitorNoneZ_ok(o: number): number {
14988 if(!isWasmInitialized) {
14989 throw new Error("initializeWasm() must be awaited first!");
14991 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
14992 return nativeResponseValue;
14994 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
14996 export function CResult_LockedChannelMonitorNoneZ_err(): number {
14997 if(!isWasmInitialized) {
14998 throw new Error("initializeWasm() must be awaited first!");
15000 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
15001 return nativeResponseValue;
15003 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
15005 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: number): boolean {
15006 if(!isWasmInitialized) {
15007 throw new Error("initializeWasm() must be awaited first!");
15009 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
15010 return nativeResponseValue;
15012 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
15014 export function CResult_LockedChannelMonitorNoneZ_free(_res: number): void {
15015 if(!isWasmInitialized) {
15016 throw new Error("initializeWasm() must be awaited first!");
15018 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
15019 // debug statements here
15021 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
15023 export function CVec_OutPointZ_free(_res: number): void {
15024 if(!isWasmInitialized) {
15025 throw new Error("initializeWasm() must be awaited first!");
15027 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
15028 // debug statements here
15030 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
15032 export function PaymentPurpose_free(this_ptr: number): void {
15033 if(!isWasmInitialized) {
15034 throw new Error("initializeWasm() must be awaited first!");
15036 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
15037 // debug statements here
15039 // uintptr_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
15041 export function PaymentPurpose_clone_ptr(arg: number): number {
15042 if(!isWasmInitialized) {
15043 throw new Error("initializeWasm() must be awaited first!");
15045 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
15046 return nativeResponseValue;
15048 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
15050 export function PaymentPurpose_clone(orig: number): number {
15051 if(!isWasmInitialized) {
15052 throw new Error("initializeWasm() must be awaited first!");
15054 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
15055 return nativeResponseValue;
15057 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
15059 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): number {
15060 if(!isWasmInitialized) {
15061 throw new Error("initializeWasm() must be awaited first!");
15063 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
15064 return nativeResponseValue;
15066 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
15068 export function PaymentPurpose_spontaneous_payment(a: number): number {
15069 if(!isWasmInitialized) {
15070 throw new Error("initializeWasm() must be awaited first!");
15072 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
15073 return nativeResponseValue;
15075 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
15077 export function PaymentPurpose_write(obj: number): number {
15078 if(!isWasmInitialized) {
15079 throw new Error("initializeWasm() must be awaited first!");
15081 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
15082 return nativeResponseValue;
15084 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
15086 export function PaymentPurpose_read(ser: number): number {
15087 if(!isWasmInitialized) {
15088 throw new Error("initializeWasm() must be awaited first!");
15090 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
15091 return nativeResponseValue;
15093 // void ClosureReason_free(struct LDKClosureReason this_ptr);
15095 export function ClosureReason_free(this_ptr: number): void {
15096 if(!isWasmInitialized) {
15097 throw new Error("initializeWasm() must be awaited first!");
15099 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
15100 // debug statements here
15102 // uintptr_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
15104 export function ClosureReason_clone_ptr(arg: number): number {
15105 if(!isWasmInitialized) {
15106 throw new Error("initializeWasm() must be awaited first!");
15108 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
15109 return nativeResponseValue;
15111 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
15113 export function ClosureReason_clone(orig: number): number {
15114 if(!isWasmInitialized) {
15115 throw new Error("initializeWasm() must be awaited first!");
15117 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
15118 return nativeResponseValue;
15120 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
15122 export function ClosureReason_counterparty_force_closed(peer_msg: number): number {
15123 if(!isWasmInitialized) {
15124 throw new Error("initializeWasm() must be awaited first!");
15126 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
15127 return nativeResponseValue;
15129 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
15131 export function ClosureReason_holder_force_closed(): number {
15132 if(!isWasmInitialized) {
15133 throw new Error("initializeWasm() must be awaited first!");
15135 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
15136 return nativeResponseValue;
15138 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
15140 export function ClosureReason_cooperative_closure(): number {
15141 if(!isWasmInitialized) {
15142 throw new Error("initializeWasm() must be awaited first!");
15144 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
15145 return nativeResponseValue;
15147 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
15149 export function ClosureReason_commitment_tx_confirmed(): number {
15150 if(!isWasmInitialized) {
15151 throw new Error("initializeWasm() must be awaited first!");
15153 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
15154 return nativeResponseValue;
15156 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
15158 export function ClosureReason_funding_timed_out(): number {
15159 if(!isWasmInitialized) {
15160 throw new Error("initializeWasm() must be awaited first!");
15162 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
15163 return nativeResponseValue;
15165 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
15167 export function ClosureReason_processing_error(err: number): number {
15168 if(!isWasmInitialized) {
15169 throw new Error("initializeWasm() must be awaited first!");
15171 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
15172 return nativeResponseValue;
15174 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
15176 export function ClosureReason_disconnected_peer(): number {
15177 if(!isWasmInitialized) {
15178 throw new Error("initializeWasm() must be awaited first!");
15180 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
15181 return nativeResponseValue;
15183 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
15185 export function ClosureReason_outdated_channel_manager(): number {
15186 if(!isWasmInitialized) {
15187 throw new Error("initializeWasm() must be awaited first!");
15189 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
15190 return nativeResponseValue;
15192 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
15194 export function ClosureReason_write(obj: number): number {
15195 if(!isWasmInitialized) {
15196 throw new Error("initializeWasm() must be awaited first!");
15198 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
15199 return nativeResponseValue;
15201 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
15203 export function ClosureReason_read(ser: number): number {
15204 if(!isWasmInitialized) {
15205 throw new Error("initializeWasm() must be awaited first!");
15207 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
15208 return nativeResponseValue;
15210 // void Event_free(struct LDKEvent this_ptr);
15212 export function Event_free(this_ptr: number): void {
15213 if(!isWasmInitialized) {
15214 throw new Error("initializeWasm() must be awaited first!");
15216 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
15217 // debug statements here
15219 // uintptr_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
15221 export function Event_clone_ptr(arg: number): number {
15222 if(!isWasmInitialized) {
15223 throw new Error("initializeWasm() must be awaited first!");
15225 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
15226 return nativeResponseValue;
15228 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
15230 export function Event_clone(orig: number): number {
15231 if(!isWasmInitialized) {
15232 throw new Error("initializeWasm() must be awaited first!");
15234 const nativeResponseValue = wasm.TS_Event_clone(orig);
15235 return nativeResponseValue;
15237 // 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);
15239 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 {
15240 if(!isWasmInitialized) {
15241 throw new Error("initializeWasm() must be awaited first!");
15243 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
15244 return nativeResponseValue;
15246 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15248 export function Event_payment_received(payment_hash: number, amount_msat: bigint, purpose: number): number {
15249 if(!isWasmInitialized) {
15250 throw new Error("initializeWasm() must be awaited first!");
15252 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amount_msat, purpose);
15253 return nativeResponseValue;
15255 // struct LDKEvent Event_payment_claimed(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15257 export function Event_payment_claimed(payment_hash: number, amount_msat: bigint, purpose: number): number {
15258 if(!isWasmInitialized) {
15259 throw new Error("initializeWasm() must be awaited first!");
15261 const nativeResponseValue = wasm.TS_Event_payment_claimed(payment_hash, amount_msat, purpose);
15262 return nativeResponseValue;
15264 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
15266 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: number): number {
15267 if(!isWasmInitialized) {
15268 throw new Error("initializeWasm() must be awaited first!");
15270 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
15271 return nativeResponseValue;
15273 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
15275 export function Event_payment_failed(payment_id: number, payment_hash: number): number {
15276 if(!isWasmInitialized) {
15277 throw new Error("initializeWasm() must be awaited first!");
15279 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
15280 return nativeResponseValue;
15282 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
15284 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): number {
15285 if(!isWasmInitialized) {
15286 throw new Error("initializeWasm() must be awaited first!");
15288 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
15289 return nativeResponseValue;
15291 // 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);
15293 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 {
15294 if(!isWasmInitialized) {
15295 throw new Error("initializeWasm() must be awaited first!");
15297 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);
15298 return nativeResponseValue;
15300 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
15302 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): number {
15303 if(!isWasmInitialized) {
15304 throw new Error("initializeWasm() must be awaited first!");
15306 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
15307 return nativeResponseValue;
15309 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
15311 export function Event_spendable_outputs(outputs: number): number {
15312 if(!isWasmInitialized) {
15313 throw new Error("initializeWasm() must be awaited first!");
15315 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
15316 return nativeResponseValue;
15318 // 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);
15320 export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: number, claim_from_onchain_tx: boolean): number {
15321 if(!isWasmInitialized) {
15322 throw new Error("initializeWasm() must be awaited first!");
15324 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx);
15325 return nativeResponseValue;
15327 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
15329 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: number): number {
15330 if(!isWasmInitialized) {
15331 throw new Error("initializeWasm() must be awaited first!");
15333 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
15334 return nativeResponseValue;
15336 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
15338 export function Event_discard_funding(channel_id: number, transaction: number): number {
15339 if(!isWasmInitialized) {
15340 throw new Error("initializeWasm() must be awaited first!");
15342 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
15343 return nativeResponseValue;
15345 // 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);
15347 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: number): number {
15348 if(!isWasmInitialized) {
15349 throw new Error("initializeWasm() must be awaited first!");
15351 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
15352 return nativeResponseValue;
15354 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
15356 export function Event_write(obj: number): number {
15357 if(!isWasmInitialized) {
15358 throw new Error("initializeWasm() must be awaited first!");
15360 const nativeResponseValue = wasm.TS_Event_write(obj);
15361 return nativeResponseValue;
15363 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
15365 export function Event_read(ser: number): number {
15366 if(!isWasmInitialized) {
15367 throw new Error("initializeWasm() must be awaited first!");
15369 const nativeResponseValue = wasm.TS_Event_read(ser);
15370 return nativeResponseValue;
15372 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
15374 export function MessageSendEvent_free(this_ptr: number): void {
15375 if(!isWasmInitialized) {
15376 throw new Error("initializeWasm() must be awaited first!");
15378 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
15379 // debug statements here
15381 // uintptr_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
15383 export function MessageSendEvent_clone_ptr(arg: number): number {
15384 if(!isWasmInitialized) {
15385 throw new Error("initializeWasm() must be awaited first!");
15387 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
15388 return nativeResponseValue;
15390 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
15392 export function MessageSendEvent_clone(orig: number): number {
15393 if(!isWasmInitialized) {
15394 throw new Error("initializeWasm() must be awaited first!");
15396 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
15397 return nativeResponseValue;
15399 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
15401 export function MessageSendEvent_send_accept_channel(node_id: number, msg: number): number {
15402 if(!isWasmInitialized) {
15403 throw new Error("initializeWasm() must be awaited first!");
15405 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
15406 return nativeResponseValue;
15408 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
15410 export function MessageSendEvent_send_open_channel(node_id: number, msg: number): number {
15411 if(!isWasmInitialized) {
15412 throw new Error("initializeWasm() must be awaited first!");
15414 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
15415 return nativeResponseValue;
15417 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
15419 export function MessageSendEvent_send_funding_created(node_id: number, msg: number): number {
15420 if(!isWasmInitialized) {
15421 throw new Error("initializeWasm() must be awaited first!");
15423 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
15424 return nativeResponseValue;
15426 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
15428 export function MessageSendEvent_send_funding_signed(node_id: number, msg: number): number {
15429 if(!isWasmInitialized) {
15430 throw new Error("initializeWasm() must be awaited first!");
15432 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
15433 return nativeResponseValue;
15435 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
15437 export function MessageSendEvent_send_channel_ready(node_id: number, msg: number): number {
15438 if(!isWasmInitialized) {
15439 throw new Error("initializeWasm() must be awaited first!");
15441 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
15442 return nativeResponseValue;
15444 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
15446 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: number): number {
15447 if(!isWasmInitialized) {
15448 throw new Error("initializeWasm() must be awaited first!");
15450 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
15451 return nativeResponseValue;
15453 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
15455 export function MessageSendEvent_update_htlcs(node_id: number, updates: number): number {
15456 if(!isWasmInitialized) {
15457 throw new Error("initializeWasm() must be awaited first!");
15459 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
15460 return nativeResponseValue;
15462 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
15464 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: number): number {
15465 if(!isWasmInitialized) {
15466 throw new Error("initializeWasm() must be awaited first!");
15468 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
15469 return nativeResponseValue;
15471 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
15473 export function MessageSendEvent_send_closing_signed(node_id: number, msg: number): number {
15474 if(!isWasmInitialized) {
15475 throw new Error("initializeWasm() must be awaited first!");
15477 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
15478 return nativeResponseValue;
15480 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
15482 export function MessageSendEvent_send_shutdown(node_id: number, msg: number): number {
15483 if(!isWasmInitialized) {
15484 throw new Error("initializeWasm() must be awaited first!");
15486 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
15487 return nativeResponseValue;
15489 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
15491 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: number): number {
15492 if(!isWasmInitialized) {
15493 throw new Error("initializeWasm() must be awaited first!");
15495 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
15496 return nativeResponseValue;
15498 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
15500 export function MessageSendEvent_broadcast_channel_announcement(msg: number, update_msg: number): number {
15501 if(!isWasmInitialized) {
15502 throw new Error("initializeWasm() must be awaited first!");
15504 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
15505 return nativeResponseValue;
15507 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
15509 export function MessageSendEvent_broadcast_node_announcement(msg: number): number {
15510 if(!isWasmInitialized) {
15511 throw new Error("initializeWasm() must be awaited first!");
15513 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
15514 return nativeResponseValue;
15516 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
15518 export function MessageSendEvent_broadcast_channel_update(msg: number): number {
15519 if(!isWasmInitialized) {
15520 throw new Error("initializeWasm() must be awaited first!");
15522 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
15523 return nativeResponseValue;
15525 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
15527 export function MessageSendEvent_send_channel_update(node_id: number, msg: number): number {
15528 if(!isWasmInitialized) {
15529 throw new Error("initializeWasm() must be awaited first!");
15531 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
15532 return nativeResponseValue;
15534 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
15536 export function MessageSendEvent_handle_error(node_id: number, action: number): number {
15537 if(!isWasmInitialized) {
15538 throw new Error("initializeWasm() must be awaited first!");
15540 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
15541 return nativeResponseValue;
15543 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
15545 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: number): number {
15546 if(!isWasmInitialized) {
15547 throw new Error("initializeWasm() must be awaited first!");
15549 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
15550 return nativeResponseValue;
15552 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
15554 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: number): number {
15555 if(!isWasmInitialized) {
15556 throw new Error("initializeWasm() must be awaited first!");
15558 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
15559 return nativeResponseValue;
15561 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
15563 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: number): number {
15564 if(!isWasmInitialized) {
15565 throw new Error("initializeWasm() must be awaited first!");
15567 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
15568 return nativeResponseValue;
15570 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
15572 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: number): number {
15573 if(!isWasmInitialized) {
15574 throw new Error("initializeWasm() must be awaited first!");
15576 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
15577 return nativeResponseValue;
15579 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
15581 export function MessageSendEventsProvider_free(this_ptr: number): void {
15582 if(!isWasmInitialized) {
15583 throw new Error("initializeWasm() must be awaited first!");
15585 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
15586 // debug statements here
15588 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
15590 export function EventsProvider_free(this_ptr: number): void {
15591 if(!isWasmInitialized) {
15592 throw new Error("initializeWasm() must be awaited first!");
15594 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
15595 // debug statements here
15597 // void EventHandler_free(struct LDKEventHandler this_ptr);
15599 export function EventHandler_free(this_ptr: number): void {
15600 if(!isWasmInitialized) {
15601 throw new Error("initializeWasm() must be awaited first!");
15603 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
15604 // debug statements here
15606 // void APIError_free(struct LDKAPIError this_ptr);
15608 export function APIError_free(this_ptr: number): void {
15609 if(!isWasmInitialized) {
15610 throw new Error("initializeWasm() must be awaited first!");
15612 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
15613 // debug statements here
15615 // uintptr_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
15617 export function APIError_clone_ptr(arg: number): number {
15618 if(!isWasmInitialized) {
15619 throw new Error("initializeWasm() must be awaited first!");
15621 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
15622 return nativeResponseValue;
15624 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
15626 export function APIError_clone(orig: number): number {
15627 if(!isWasmInitialized) {
15628 throw new Error("initializeWasm() must be awaited first!");
15630 const nativeResponseValue = wasm.TS_APIError_clone(orig);
15631 return nativeResponseValue;
15633 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
15635 export function APIError_apimisuse_error(err: number): number {
15636 if(!isWasmInitialized) {
15637 throw new Error("initializeWasm() must be awaited first!");
15639 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
15640 return nativeResponseValue;
15642 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
15644 export function APIError_fee_rate_too_high(err: number, feerate: number): number {
15645 if(!isWasmInitialized) {
15646 throw new Error("initializeWasm() must be awaited first!");
15648 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
15649 return nativeResponseValue;
15651 // struct LDKAPIError APIError_route_error(struct LDKStr err);
15653 export function APIError_route_error(err: number): number {
15654 if(!isWasmInitialized) {
15655 throw new Error("initializeWasm() must be awaited first!");
15657 const nativeResponseValue = wasm.TS_APIError_route_error(err);
15658 return nativeResponseValue;
15660 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
15662 export function APIError_channel_unavailable(err: number): number {
15663 if(!isWasmInitialized) {
15664 throw new Error("initializeWasm() must be awaited first!");
15666 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
15667 return nativeResponseValue;
15669 // struct LDKAPIError APIError_monitor_update_failed(void);
15671 export function APIError_monitor_update_failed(): number {
15672 if(!isWasmInitialized) {
15673 throw new Error("initializeWasm() must be awaited first!");
15675 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
15676 return nativeResponseValue;
15678 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
15680 export function APIError_incompatible_shutdown_script(script: number): number {
15681 if(!isWasmInitialized) {
15682 throw new Error("initializeWasm() must be awaited first!");
15684 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
15685 return nativeResponseValue;
15687 // void BigSize_free(struct LDKBigSize this_obj);
15689 export function BigSize_free(this_obj: number): void {
15690 if(!isWasmInitialized) {
15691 throw new Error("initializeWasm() must be awaited first!");
15693 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
15694 // debug statements here
15696 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
15698 export function BigSize_get_a(this_ptr: number): bigint {
15699 if(!isWasmInitialized) {
15700 throw new Error("initializeWasm() must be awaited first!");
15702 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
15703 return nativeResponseValue;
15705 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
15707 export function BigSize_set_a(this_ptr: number, val: bigint): void {
15708 if(!isWasmInitialized) {
15709 throw new Error("initializeWasm() must be awaited first!");
15711 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
15712 // debug statements here
15714 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
15716 export function BigSize_new(a_arg: bigint): number {
15717 if(!isWasmInitialized) {
15718 throw new Error("initializeWasm() must be awaited first!");
15720 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
15721 return nativeResponseValue;
15723 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
15725 export function sign(msg: number, sk: number): number {
15726 if(!isWasmInitialized) {
15727 throw new Error("initializeWasm() must be awaited first!");
15729 const nativeResponseValue = wasm.TS_sign(msg, sk);
15730 return nativeResponseValue;
15732 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
15734 export function recover_pk(msg: number, sig: number): number {
15735 if(!isWasmInitialized) {
15736 throw new Error("initializeWasm() must be awaited first!");
15738 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
15739 return nativeResponseValue;
15741 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
15743 export function verify(msg: number, sig: number, pk: number): boolean {
15744 if(!isWasmInitialized) {
15745 throw new Error("initializeWasm() must be awaited first!");
15747 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
15748 return nativeResponseValue;
15750 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z data_without_signature);
15752 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
15753 if(!isWasmInitialized) {
15754 throw new Error("initializeWasm() must be awaited first!");
15756 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
15757 return nativeResponseValue;
15759 // void Persister_free(struct LDKPersister this_ptr);
15761 export function Persister_free(this_ptr: number): void {
15762 if(!isWasmInitialized) {
15763 throw new Error("initializeWasm() must be awaited first!");
15765 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
15766 // debug statements here
15768 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
15770 export function Level_clone(orig: number): Level {
15771 if(!isWasmInitialized) {
15772 throw new Error("initializeWasm() must be awaited first!");
15774 const nativeResponseValue = wasm.TS_Level_clone(orig);
15775 return nativeResponseValue;
15777 // enum LDKLevel Level_gossip(void);
15779 export function Level_gossip(): Level {
15780 if(!isWasmInitialized) {
15781 throw new Error("initializeWasm() must be awaited first!");
15783 const nativeResponseValue = wasm.TS_Level_gossip();
15784 return nativeResponseValue;
15786 // enum LDKLevel Level_trace(void);
15788 export function Level_trace(): Level {
15789 if(!isWasmInitialized) {
15790 throw new Error("initializeWasm() must be awaited first!");
15792 const nativeResponseValue = wasm.TS_Level_trace();
15793 return nativeResponseValue;
15795 // enum LDKLevel Level_debug(void);
15797 export function Level_debug(): Level {
15798 if(!isWasmInitialized) {
15799 throw new Error("initializeWasm() must be awaited first!");
15801 const nativeResponseValue = wasm.TS_Level_debug();
15802 return nativeResponseValue;
15804 // enum LDKLevel Level_info(void);
15806 export function Level_info(): Level {
15807 if(!isWasmInitialized) {
15808 throw new Error("initializeWasm() must be awaited first!");
15810 const nativeResponseValue = wasm.TS_Level_info();
15811 return nativeResponseValue;
15813 // enum LDKLevel Level_warn(void);
15815 export function Level_warn(): Level {
15816 if(!isWasmInitialized) {
15817 throw new Error("initializeWasm() must be awaited first!");
15819 const nativeResponseValue = wasm.TS_Level_warn();
15820 return nativeResponseValue;
15822 // enum LDKLevel Level_error(void);
15824 export function Level_error(): Level {
15825 if(!isWasmInitialized) {
15826 throw new Error("initializeWasm() must be awaited first!");
15828 const nativeResponseValue = wasm.TS_Level_error();
15829 return nativeResponseValue;
15831 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
15833 export function Level_eq(a: number, b: number): boolean {
15834 if(!isWasmInitialized) {
15835 throw new Error("initializeWasm() must be awaited first!");
15837 const nativeResponseValue = wasm.TS_Level_eq(a, b);
15838 return nativeResponseValue;
15840 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
15842 export function Level_hash(o: number): bigint {
15843 if(!isWasmInitialized) {
15844 throw new Error("initializeWasm() must be awaited first!");
15846 const nativeResponseValue = wasm.TS_Level_hash(o);
15847 return nativeResponseValue;
15849 // MUST_USE_RES enum LDKLevel Level_max(void);
15851 export function Level_max(): Level {
15852 if(!isWasmInitialized) {
15853 throw new Error("initializeWasm() must be awaited first!");
15855 const nativeResponseValue = wasm.TS_Level_max();
15856 return nativeResponseValue;
15858 // void Record_free(struct LDKRecord this_obj);
15860 export function Record_free(this_obj: number): void {
15861 if(!isWasmInitialized) {
15862 throw new Error("initializeWasm() must be awaited first!");
15864 const nativeResponseValue = wasm.TS_Record_free(this_obj);
15865 // debug statements here
15867 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
15869 export function Record_get_level(this_ptr: number): Level {
15870 if(!isWasmInitialized) {
15871 throw new Error("initializeWasm() must be awaited first!");
15873 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
15874 return nativeResponseValue;
15876 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
15878 export function Record_set_level(this_ptr: number, val: Level): void {
15879 if(!isWasmInitialized) {
15880 throw new Error("initializeWasm() must be awaited first!");
15882 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
15883 // debug statements here
15885 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
15887 export function Record_get_args(this_ptr: number): number {
15888 if(!isWasmInitialized) {
15889 throw new Error("initializeWasm() must be awaited first!");
15891 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
15892 return nativeResponseValue;
15894 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15896 export function Record_set_args(this_ptr: number, val: number): void {
15897 if(!isWasmInitialized) {
15898 throw new Error("initializeWasm() must be awaited first!");
15900 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
15901 // debug statements here
15903 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
15905 export function Record_get_module_path(this_ptr: number): number {
15906 if(!isWasmInitialized) {
15907 throw new Error("initializeWasm() must be awaited first!");
15909 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
15910 return nativeResponseValue;
15912 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15914 export function Record_set_module_path(this_ptr: number, val: number): void {
15915 if(!isWasmInitialized) {
15916 throw new Error("initializeWasm() must be awaited first!");
15918 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
15919 // debug statements here
15921 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
15923 export function Record_get_file(this_ptr: number): number {
15924 if(!isWasmInitialized) {
15925 throw new Error("initializeWasm() must be awaited first!");
15927 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
15928 return nativeResponseValue;
15930 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
15932 export function Record_set_file(this_ptr: number, val: number): void {
15933 if(!isWasmInitialized) {
15934 throw new Error("initializeWasm() must be awaited first!");
15936 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
15937 // debug statements here
15939 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
15941 export function Record_get_line(this_ptr: number): number {
15942 if(!isWasmInitialized) {
15943 throw new Error("initializeWasm() must be awaited first!");
15945 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
15946 return nativeResponseValue;
15948 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
15950 export function Record_set_line(this_ptr: number, val: number): void {
15951 if(!isWasmInitialized) {
15952 throw new Error("initializeWasm() must be awaited first!");
15954 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
15955 // debug statements here
15957 // uintptr_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
15959 export function Record_clone_ptr(arg: number): number {
15960 if(!isWasmInitialized) {
15961 throw new Error("initializeWasm() must be awaited first!");
15963 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
15964 return nativeResponseValue;
15966 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
15968 export function Record_clone(orig: number): number {
15969 if(!isWasmInitialized) {
15970 throw new Error("initializeWasm() must be awaited first!");
15972 const nativeResponseValue = wasm.TS_Record_clone(orig);
15973 return nativeResponseValue;
15975 // void Logger_free(struct LDKLogger this_ptr);
15977 export function Logger_free(this_ptr: number): void {
15978 if(!isWasmInitialized) {
15979 throw new Error("initializeWasm() must be awaited first!");
15981 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
15982 // debug statements here
15984 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
15986 export function ChannelHandshakeConfig_free(this_obj: number): void {
15987 if(!isWasmInitialized) {
15988 throw new Error("initializeWasm() must be awaited first!");
15990 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
15991 // debug statements here
15993 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
15995 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
15996 if(!isWasmInitialized) {
15997 throw new Error("initializeWasm() must be awaited first!");
15999 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
16000 return nativeResponseValue;
16002 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
16004 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
16005 if(!isWasmInitialized) {
16006 throw new Error("initializeWasm() must be awaited first!");
16008 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
16009 // debug statements here
16011 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16013 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
16014 if(!isWasmInitialized) {
16015 throw new Error("initializeWasm() must be awaited first!");
16017 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
16018 return nativeResponseValue;
16020 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
16022 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: number, val: number): void {
16023 if(!isWasmInitialized) {
16024 throw new Error("initializeWasm() must be awaited first!");
16026 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
16027 // debug statements here
16029 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16031 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): bigint {
16032 if(!isWasmInitialized) {
16033 throw new Error("initializeWasm() must be awaited first!");
16035 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
16036 return nativeResponseValue;
16038 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
16040 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16041 if(!isWasmInitialized) {
16042 throw new Error("initializeWasm() must be awaited first!");
16044 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
16045 // debug statements here
16047 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16049 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: number): number {
16050 if(!isWasmInitialized) {
16051 throw new Error("initializeWasm() must be awaited first!");
16053 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
16054 return nativeResponseValue;
16056 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
16058 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: number, val: number): void {
16059 if(!isWasmInitialized) {
16060 throw new Error("initializeWasm() must be awaited first!");
16062 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
16063 // debug statements here
16065 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16067 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: number): boolean {
16068 if(!isWasmInitialized) {
16069 throw new Error("initializeWasm() must be awaited first!");
16071 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
16072 return nativeResponseValue;
16074 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16076 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: number, val: boolean): void {
16077 if(!isWasmInitialized) {
16078 throw new Error("initializeWasm() must be awaited first!");
16080 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
16081 // debug statements here
16083 // 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);
16085 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): number {
16086 if(!isWasmInitialized) {
16087 throw new Error("initializeWasm() must be awaited first!");
16089 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);
16090 return nativeResponseValue;
16092 // uintptr_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
16094 export function ChannelHandshakeConfig_clone_ptr(arg: number): number {
16095 if(!isWasmInitialized) {
16096 throw new Error("initializeWasm() must be awaited first!");
16098 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
16099 return nativeResponseValue;
16101 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
16103 export function ChannelHandshakeConfig_clone(orig: number): number {
16104 if(!isWasmInitialized) {
16105 throw new Error("initializeWasm() must be awaited first!");
16107 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
16108 return nativeResponseValue;
16110 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
16112 export function ChannelHandshakeConfig_default(): number {
16113 if(!isWasmInitialized) {
16114 throw new Error("initializeWasm() must be awaited first!");
16116 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
16117 return nativeResponseValue;
16119 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
16121 export function ChannelHandshakeLimits_free(this_obj: number): void {
16122 if(!isWasmInitialized) {
16123 throw new Error("initializeWasm() must be awaited first!");
16125 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
16126 // debug statements here
16128 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16130 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): bigint {
16131 if(!isWasmInitialized) {
16132 throw new Error("initializeWasm() must be awaited first!");
16134 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
16135 return nativeResponseValue;
16137 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16139 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: bigint): void {
16140 if(!isWasmInitialized) {
16141 throw new Error("initializeWasm() must be awaited first!");
16143 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
16144 // debug statements here
16146 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16148 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: number): bigint {
16149 if(!isWasmInitialized) {
16150 throw new Error("initializeWasm() must be awaited first!");
16152 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
16153 return nativeResponseValue;
16155 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16157 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: number, val: bigint): void {
16158 if(!isWasmInitialized) {
16159 throw new Error("initializeWasm() must be awaited first!");
16161 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
16162 // debug statements here
16164 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16166 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): bigint {
16167 if(!isWasmInitialized) {
16168 throw new Error("initializeWasm() must be awaited first!");
16170 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
16171 return nativeResponseValue;
16173 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16175 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16176 if(!isWasmInitialized) {
16177 throw new Error("initializeWasm() must be awaited first!");
16179 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
16180 // debug statements here
16182 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16184 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
16185 if(!isWasmInitialized) {
16186 throw new Error("initializeWasm() must be awaited first!");
16188 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
16189 return nativeResponseValue;
16191 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16193 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
16194 if(!isWasmInitialized) {
16195 throw new Error("initializeWasm() must be awaited first!");
16197 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
16198 // debug statements here
16200 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16202 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): bigint {
16203 if(!isWasmInitialized) {
16204 throw new Error("initializeWasm() must be awaited first!");
16206 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
16207 return nativeResponseValue;
16209 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16211 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
16212 if(!isWasmInitialized) {
16213 throw new Error("initializeWasm() must be awaited first!");
16215 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
16216 // debug statements here
16218 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16220 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
16221 if(!isWasmInitialized) {
16222 throw new Error("initializeWasm() must be awaited first!");
16224 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
16225 return nativeResponseValue;
16227 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
16229 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
16230 if(!isWasmInitialized) {
16231 throw new Error("initializeWasm() must be awaited first!");
16233 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
16234 // debug statements here
16236 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16238 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
16239 if(!isWasmInitialized) {
16240 throw new Error("initializeWasm() must be awaited first!");
16242 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
16243 return nativeResponseValue;
16245 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
16247 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: number, val: number): void {
16248 if(!isWasmInitialized) {
16249 throw new Error("initializeWasm() must be awaited first!");
16251 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
16252 // debug statements here
16254 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16256 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: number): boolean {
16257 if(!isWasmInitialized) {
16258 throw new Error("initializeWasm() must be awaited first!");
16260 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
16261 return nativeResponseValue;
16263 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
16265 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: number, val: boolean): void {
16266 if(!isWasmInitialized) {
16267 throw new Error("initializeWasm() must be awaited first!");
16269 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
16270 // debug statements here
16272 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16274 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
16275 if(!isWasmInitialized) {
16276 throw new Error("initializeWasm() must be awaited first!");
16278 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
16279 return nativeResponseValue;
16281 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
16283 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
16284 if(!isWasmInitialized) {
16285 throw new Error("initializeWasm() must be awaited first!");
16287 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
16288 // debug statements here
16290 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16292 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
16293 if(!isWasmInitialized) {
16294 throw new Error("initializeWasm() must be awaited first!");
16296 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
16297 return nativeResponseValue;
16299 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
16301 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
16302 if(!isWasmInitialized) {
16303 throw new Error("initializeWasm() must be awaited first!");
16305 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
16306 // debug statements here
16308 // 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);
16310 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 {
16311 if(!isWasmInitialized) {
16312 throw new Error("initializeWasm() must be awaited first!");
16314 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);
16315 return nativeResponseValue;
16317 // uintptr_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
16319 export function ChannelHandshakeLimits_clone_ptr(arg: number): number {
16320 if(!isWasmInitialized) {
16321 throw new Error("initializeWasm() must be awaited first!");
16323 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
16324 return nativeResponseValue;
16326 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
16328 export function ChannelHandshakeLimits_clone(orig: number): number {
16329 if(!isWasmInitialized) {
16330 throw new Error("initializeWasm() must be awaited first!");
16332 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
16333 return nativeResponseValue;
16335 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
16337 export function ChannelHandshakeLimits_default(): number {
16338 if(!isWasmInitialized) {
16339 throw new Error("initializeWasm() must be awaited first!");
16341 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
16342 return nativeResponseValue;
16344 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
16346 export function ChannelConfig_free(this_obj: number): void {
16347 if(!isWasmInitialized) {
16348 throw new Error("initializeWasm() must be awaited first!");
16350 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
16351 // debug statements here
16353 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16355 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: number): number {
16356 if(!isWasmInitialized) {
16357 throw new Error("initializeWasm() must be awaited first!");
16359 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
16360 return nativeResponseValue;
16362 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
16364 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: number, val: number): void {
16365 if(!isWasmInitialized) {
16366 throw new Error("initializeWasm() must be awaited first!");
16368 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
16369 // debug statements here
16371 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16373 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: number): number {
16374 if(!isWasmInitialized) {
16375 throw new Error("initializeWasm() must be awaited first!");
16377 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
16378 return nativeResponseValue;
16380 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
16382 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: number, val: number): void {
16383 if(!isWasmInitialized) {
16384 throw new Error("initializeWasm() must be awaited first!");
16386 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
16387 // debug statements here
16389 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16391 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
16392 if(!isWasmInitialized) {
16393 throw new Error("initializeWasm() must be awaited first!");
16395 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
16396 return nativeResponseValue;
16398 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
16400 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
16401 if(!isWasmInitialized) {
16402 throw new Error("initializeWasm() must be awaited first!");
16404 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
16405 // debug statements here
16407 // bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16409 export function ChannelConfig_get_announced_channel(this_ptr: number): boolean {
16410 if(!isWasmInitialized) {
16411 throw new Error("initializeWasm() must be awaited first!");
16413 const nativeResponseValue = wasm.TS_ChannelConfig_get_announced_channel(this_ptr);
16414 return nativeResponseValue;
16416 // void ChannelConfig_set_announced_channel(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
16418 export function ChannelConfig_set_announced_channel(this_ptr: number, val: boolean): void {
16419 if(!isWasmInitialized) {
16420 throw new Error("initializeWasm() must be awaited first!");
16422 const nativeResponseValue = wasm.TS_ChannelConfig_set_announced_channel(this_ptr, val);
16423 // debug statements here
16425 // bool ChannelConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16427 export function ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr: number): boolean {
16428 if(!isWasmInitialized) {
16429 throw new Error("initializeWasm() must be awaited first!");
16431 const nativeResponseValue = wasm.TS_ChannelConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
16432 return nativeResponseValue;
16434 // void ChannelConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelConfig *NONNULL_PTR this_ptr, bool val);
16436 export function ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr: number, val: boolean): void {
16437 if(!isWasmInitialized) {
16438 throw new Error("initializeWasm() must be awaited first!");
16440 const nativeResponseValue = wasm.TS_ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
16441 // debug statements here
16443 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16445 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: number): bigint {
16446 if(!isWasmInitialized) {
16447 throw new Error("initializeWasm() must be awaited first!");
16449 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
16450 return nativeResponseValue;
16452 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
16454 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: number, val: bigint): void {
16455 if(!isWasmInitialized) {
16456 throw new Error("initializeWasm() must be awaited first!");
16458 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
16459 // debug statements here
16461 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16463 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: number): bigint {
16464 if(!isWasmInitialized) {
16465 throw new Error("initializeWasm() must be awaited first!");
16467 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
16468 return nativeResponseValue;
16470 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
16472 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: number, val: bigint): void {
16473 if(!isWasmInitialized) {
16474 throw new Error("initializeWasm() must be awaited first!");
16476 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
16477 // debug statements here
16479 // 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, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg, uint64_t max_dust_htlc_exposure_msat_arg, uint64_t force_close_avoidance_max_fee_satoshis_arg);
16481 export function ChannelConfig_new(forwarding_fee_proportional_millionths_arg: number, forwarding_fee_base_msat_arg: number, cltv_expiry_delta_arg: number, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean, max_dust_htlc_exposure_msat_arg: bigint, force_close_avoidance_max_fee_satoshis_arg: bigint): number {
16482 if(!isWasmInitialized) {
16483 throw new Error("initializeWasm() must be awaited first!");
16485 const nativeResponseValue = wasm.TS_ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg, max_dust_htlc_exposure_msat_arg, force_close_avoidance_max_fee_satoshis_arg);
16486 return nativeResponseValue;
16488 // uintptr_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
16490 export function ChannelConfig_clone_ptr(arg: number): number {
16491 if(!isWasmInitialized) {
16492 throw new Error("initializeWasm() must be awaited first!");
16494 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
16495 return nativeResponseValue;
16497 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
16499 export function ChannelConfig_clone(orig: number): number {
16500 if(!isWasmInitialized) {
16501 throw new Error("initializeWasm() must be awaited first!");
16503 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
16504 return nativeResponseValue;
16506 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
16508 export function ChannelConfig_default(): number {
16509 if(!isWasmInitialized) {
16510 throw new Error("initializeWasm() must be awaited first!");
16512 const nativeResponseValue = wasm.TS_ChannelConfig_default();
16513 return nativeResponseValue;
16515 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
16517 export function ChannelConfig_write(obj: number): number {
16518 if(!isWasmInitialized) {
16519 throw new Error("initializeWasm() must be awaited first!");
16521 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
16522 return nativeResponseValue;
16524 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
16526 export function ChannelConfig_read(ser: number): number {
16527 if(!isWasmInitialized) {
16528 throw new Error("initializeWasm() must be awaited first!");
16530 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
16531 return nativeResponseValue;
16533 // void UserConfig_free(struct LDKUserConfig this_obj);
16535 export function UserConfig_free(this_obj: number): void {
16536 if(!isWasmInitialized) {
16537 throw new Error("initializeWasm() must be awaited first!");
16539 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
16540 // debug statements here
16542 // struct LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16544 export function UserConfig_get_own_channel_config(this_ptr: number): number {
16545 if(!isWasmInitialized) {
16546 throw new Error("initializeWasm() must be awaited first!");
16548 const nativeResponseValue = wasm.TS_UserConfig_get_own_channel_config(this_ptr);
16549 return nativeResponseValue;
16551 // void UserConfig_set_own_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
16553 export function UserConfig_set_own_channel_config(this_ptr: number, val: number): void {
16554 if(!isWasmInitialized) {
16555 throw new Error("initializeWasm() must be awaited first!");
16557 const nativeResponseValue = wasm.TS_UserConfig_set_own_channel_config(this_ptr, val);
16558 // debug statements here
16560 // struct LDKChannelHandshakeLimits UserConfig_get_peer_channel_config_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16562 export function UserConfig_get_peer_channel_config_limits(this_ptr: number): number {
16563 if(!isWasmInitialized) {
16564 throw new Error("initializeWasm() must be awaited first!");
16566 const nativeResponseValue = wasm.TS_UserConfig_get_peer_channel_config_limits(this_ptr);
16567 return nativeResponseValue;
16569 // void UserConfig_set_peer_channel_config_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
16571 export function UserConfig_set_peer_channel_config_limits(this_ptr: number, val: number): void {
16572 if(!isWasmInitialized) {
16573 throw new Error("initializeWasm() must be awaited first!");
16575 const nativeResponseValue = wasm.TS_UserConfig_set_peer_channel_config_limits(this_ptr, val);
16576 // debug statements here
16578 // struct LDKChannelConfig UserConfig_get_channel_options(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16580 export function UserConfig_get_channel_options(this_ptr: number): number {
16581 if(!isWasmInitialized) {
16582 throw new Error("initializeWasm() must be awaited first!");
16584 const nativeResponseValue = wasm.TS_UserConfig_get_channel_options(this_ptr);
16585 return nativeResponseValue;
16587 // void UserConfig_set_channel_options(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
16589 export function UserConfig_set_channel_options(this_ptr: number, val: number): void {
16590 if(!isWasmInitialized) {
16591 throw new Error("initializeWasm() must be awaited first!");
16593 const nativeResponseValue = wasm.TS_UserConfig_set_channel_options(this_ptr, val);
16594 // debug statements here
16596 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16598 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: number): boolean {
16599 if(!isWasmInitialized) {
16600 throw new Error("initializeWasm() must be awaited first!");
16602 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
16603 return nativeResponseValue;
16605 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16607 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: number, val: boolean): void {
16608 if(!isWasmInitialized) {
16609 throw new Error("initializeWasm() must be awaited first!");
16611 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
16612 // debug statements here
16614 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16616 export function UserConfig_get_accept_inbound_channels(this_ptr: number): boolean {
16617 if(!isWasmInitialized) {
16618 throw new Error("initializeWasm() must be awaited first!");
16620 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
16621 return nativeResponseValue;
16623 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16625 export function UserConfig_set_accept_inbound_channels(this_ptr: number, val: boolean): void {
16626 if(!isWasmInitialized) {
16627 throw new Error("initializeWasm() must be awaited first!");
16629 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
16630 // debug statements here
16632 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16634 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: number): boolean {
16635 if(!isWasmInitialized) {
16636 throw new Error("initializeWasm() must be awaited first!");
16638 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
16639 return nativeResponseValue;
16641 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16643 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: number, val: boolean): void {
16644 if(!isWasmInitialized) {
16645 throw new Error("initializeWasm() must be awaited first!");
16647 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
16648 // debug statements here
16650 // MUST_USE_RES struct LDKUserConfig UserConfig_new(struct LDKChannelHandshakeConfig own_channel_config_arg, struct LDKChannelHandshakeLimits peer_channel_config_limits_arg, struct LDKChannelConfig channel_options_arg, bool accept_forwards_to_priv_channels_arg, bool accept_inbound_channels_arg, bool manually_accept_inbound_channels_arg);
16652 export function UserConfig_new(own_channel_config_arg: number, peer_channel_config_limits_arg: number, channel_options_arg: number, accept_forwards_to_priv_channels_arg: boolean, accept_inbound_channels_arg: boolean, manually_accept_inbound_channels_arg: boolean): number {
16653 if(!isWasmInitialized) {
16654 throw new Error("initializeWasm() must be awaited first!");
16656 const nativeResponseValue = wasm.TS_UserConfig_new(own_channel_config_arg, peer_channel_config_limits_arg, channel_options_arg, accept_forwards_to_priv_channels_arg, accept_inbound_channels_arg, manually_accept_inbound_channels_arg);
16657 return nativeResponseValue;
16659 // uintptr_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
16661 export function UserConfig_clone_ptr(arg: number): number {
16662 if(!isWasmInitialized) {
16663 throw new Error("initializeWasm() must be awaited first!");
16665 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
16666 return nativeResponseValue;
16668 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
16670 export function UserConfig_clone(orig: number): number {
16671 if(!isWasmInitialized) {
16672 throw new Error("initializeWasm() must be awaited first!");
16674 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
16675 return nativeResponseValue;
16677 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
16679 export function UserConfig_default(): number {
16680 if(!isWasmInitialized) {
16681 throw new Error("initializeWasm() must be awaited first!");
16683 const nativeResponseValue = wasm.TS_UserConfig_default();
16684 return nativeResponseValue;
16686 // void BestBlock_free(struct LDKBestBlock this_obj);
16688 export function BestBlock_free(this_obj: number): void {
16689 if(!isWasmInitialized) {
16690 throw new Error("initializeWasm() must be awaited first!");
16692 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
16693 // debug statements here
16695 // uintptr_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
16697 export function BestBlock_clone_ptr(arg: number): number {
16698 if(!isWasmInitialized) {
16699 throw new Error("initializeWasm() must be awaited first!");
16701 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
16702 return nativeResponseValue;
16704 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
16706 export function BestBlock_clone(orig: number): number {
16707 if(!isWasmInitialized) {
16708 throw new Error("initializeWasm() must be awaited first!");
16710 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
16711 return nativeResponseValue;
16713 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
16715 export function BestBlock_from_genesis(network: Network): number {
16716 if(!isWasmInitialized) {
16717 throw new Error("initializeWasm() must be awaited first!");
16719 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
16720 return nativeResponseValue;
16722 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
16724 export function BestBlock_new(block_hash: number, height: number): number {
16725 if(!isWasmInitialized) {
16726 throw new Error("initializeWasm() must be awaited first!");
16728 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
16729 return nativeResponseValue;
16731 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
16733 export function BestBlock_block_hash(this_arg: number): number {
16734 if(!isWasmInitialized) {
16735 throw new Error("initializeWasm() must be awaited first!");
16737 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
16738 return nativeResponseValue;
16740 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
16742 export function BestBlock_height(this_arg: number): number {
16743 if(!isWasmInitialized) {
16744 throw new Error("initializeWasm() must be awaited first!");
16746 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
16747 return nativeResponseValue;
16749 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
16751 export function AccessError_clone(orig: number): AccessError {
16752 if(!isWasmInitialized) {
16753 throw new Error("initializeWasm() must be awaited first!");
16755 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
16756 return nativeResponseValue;
16758 // enum LDKAccessError AccessError_unknown_chain(void);
16760 export function AccessError_unknown_chain(): AccessError {
16761 if(!isWasmInitialized) {
16762 throw new Error("initializeWasm() must be awaited first!");
16764 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
16765 return nativeResponseValue;
16767 // enum LDKAccessError AccessError_unknown_tx(void);
16769 export function AccessError_unknown_tx(): AccessError {
16770 if(!isWasmInitialized) {
16771 throw new Error("initializeWasm() must be awaited first!");
16773 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
16774 return nativeResponseValue;
16776 // void Access_free(struct LDKAccess this_ptr);
16778 export function Access_free(this_ptr: number): void {
16779 if(!isWasmInitialized) {
16780 throw new Error("initializeWasm() must be awaited first!");
16782 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
16783 // debug statements here
16785 // void Listen_free(struct LDKListen this_ptr);
16787 export function Listen_free(this_ptr: number): void {
16788 if(!isWasmInitialized) {
16789 throw new Error("initializeWasm() must be awaited first!");
16791 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
16792 // debug statements here
16794 // void Confirm_free(struct LDKConfirm this_ptr);
16796 export function Confirm_free(this_ptr: number): void {
16797 if(!isWasmInitialized) {
16798 throw new Error("initializeWasm() must be awaited first!");
16800 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
16801 // debug statements here
16803 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
16805 export function ChannelMonitorUpdateErr_clone(orig: number): ChannelMonitorUpdateErr {
16806 if(!isWasmInitialized) {
16807 throw new Error("initializeWasm() must be awaited first!");
16809 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
16810 return nativeResponseValue;
16812 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
16814 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
16815 if(!isWasmInitialized) {
16816 throw new Error("initializeWasm() must be awaited first!");
16818 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
16819 return nativeResponseValue;
16821 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
16823 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
16824 if(!isWasmInitialized) {
16825 throw new Error("initializeWasm() must be awaited first!");
16827 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
16828 return nativeResponseValue;
16830 // void Watch_free(struct LDKWatch this_ptr);
16832 export function Watch_free(this_ptr: number): void {
16833 if(!isWasmInitialized) {
16834 throw new Error("initializeWasm() must be awaited first!");
16836 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
16837 // debug statements here
16839 // void Filter_free(struct LDKFilter this_ptr);
16841 export function Filter_free(this_ptr: number): void {
16842 if(!isWasmInitialized) {
16843 throw new Error("initializeWasm() must be awaited first!");
16845 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
16846 // debug statements here
16848 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
16850 export function WatchedOutput_free(this_obj: number): void {
16851 if(!isWasmInitialized) {
16852 throw new Error("initializeWasm() must be awaited first!");
16854 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
16855 // debug statements here
16857 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16859 export function WatchedOutput_get_block_hash(this_ptr: number): number {
16860 if(!isWasmInitialized) {
16861 throw new Error("initializeWasm() must be awaited first!");
16863 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
16864 return nativeResponseValue;
16866 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
16868 export function WatchedOutput_set_block_hash(this_ptr: number, val: number): void {
16869 if(!isWasmInitialized) {
16870 throw new Error("initializeWasm() must be awaited first!");
16872 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
16873 // debug statements here
16875 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16877 export function WatchedOutput_get_outpoint(this_ptr: number): number {
16878 if(!isWasmInitialized) {
16879 throw new Error("initializeWasm() must be awaited first!");
16881 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
16882 return nativeResponseValue;
16884 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
16886 export function WatchedOutput_set_outpoint(this_ptr: number, val: number): void {
16887 if(!isWasmInitialized) {
16888 throw new Error("initializeWasm() must be awaited first!");
16890 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
16891 // debug statements here
16893 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
16895 export function WatchedOutput_get_script_pubkey(this_ptr: number): number {
16896 if(!isWasmInitialized) {
16897 throw new Error("initializeWasm() must be awaited first!");
16899 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
16900 return nativeResponseValue;
16902 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
16904 export function WatchedOutput_set_script_pubkey(this_ptr: number, val: number): void {
16905 if(!isWasmInitialized) {
16906 throw new Error("initializeWasm() must be awaited first!");
16908 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
16909 // debug statements here
16911 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
16913 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: number, script_pubkey_arg: number): number {
16914 if(!isWasmInitialized) {
16915 throw new Error("initializeWasm() must be awaited first!");
16917 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
16918 return nativeResponseValue;
16920 // uintptr_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
16922 export function WatchedOutput_clone_ptr(arg: number): number {
16923 if(!isWasmInitialized) {
16924 throw new Error("initializeWasm() must be awaited first!");
16926 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
16927 return nativeResponseValue;
16929 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
16931 export function WatchedOutput_clone(orig: number): number {
16932 if(!isWasmInitialized) {
16933 throw new Error("initializeWasm() must be awaited first!");
16935 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
16936 return nativeResponseValue;
16938 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
16940 export function WatchedOutput_hash(o: number): bigint {
16941 if(!isWasmInitialized) {
16942 throw new Error("initializeWasm() must be awaited first!");
16944 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
16945 return nativeResponseValue;
16947 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
16949 export function BroadcasterInterface_free(this_ptr: number): void {
16950 if(!isWasmInitialized) {
16951 throw new Error("initializeWasm() must be awaited first!");
16953 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
16954 // debug statements here
16956 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
16958 export function ConfirmationTarget_clone(orig: number): ConfirmationTarget {
16959 if(!isWasmInitialized) {
16960 throw new Error("initializeWasm() must be awaited first!");
16962 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
16963 return nativeResponseValue;
16965 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
16967 export function ConfirmationTarget_background(): ConfirmationTarget {
16968 if(!isWasmInitialized) {
16969 throw new Error("initializeWasm() must be awaited first!");
16971 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
16972 return nativeResponseValue;
16974 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
16976 export function ConfirmationTarget_normal(): ConfirmationTarget {
16977 if(!isWasmInitialized) {
16978 throw new Error("initializeWasm() must be awaited first!");
16980 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
16981 return nativeResponseValue;
16983 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
16985 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
16986 if(!isWasmInitialized) {
16987 throw new Error("initializeWasm() must be awaited first!");
16989 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
16990 return nativeResponseValue;
16992 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
16994 export function ConfirmationTarget_eq(a: number, b: number): boolean {
16995 if(!isWasmInitialized) {
16996 throw new Error("initializeWasm() must be awaited first!");
16998 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
16999 return nativeResponseValue;
17001 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
17003 export function FeeEstimator_free(this_ptr: number): void {
17004 if(!isWasmInitialized) {
17005 throw new Error("initializeWasm() must be awaited first!");
17007 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
17008 // debug statements here
17010 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
17012 export function MonitorUpdateId_free(this_obj: number): void {
17013 if(!isWasmInitialized) {
17014 throw new Error("initializeWasm() must be awaited first!");
17016 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
17017 // debug statements here
17019 // uintptr_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
17021 export function MonitorUpdateId_clone_ptr(arg: number): number {
17022 if(!isWasmInitialized) {
17023 throw new Error("initializeWasm() must be awaited first!");
17025 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
17026 return nativeResponseValue;
17028 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
17030 export function MonitorUpdateId_clone(orig: number): number {
17031 if(!isWasmInitialized) {
17032 throw new Error("initializeWasm() must be awaited first!");
17034 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
17035 return nativeResponseValue;
17037 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
17039 export function MonitorUpdateId_hash(o: number): bigint {
17040 if(!isWasmInitialized) {
17041 throw new Error("initializeWasm() must be awaited first!");
17043 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
17044 return nativeResponseValue;
17046 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
17048 export function MonitorUpdateId_eq(a: number, b: number): boolean {
17049 if(!isWasmInitialized) {
17050 throw new Error("initializeWasm() must be awaited first!");
17052 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
17053 return nativeResponseValue;
17055 // void Persist_free(struct LDKPersist this_ptr);
17057 export function Persist_free(this_ptr: number): void {
17058 if(!isWasmInitialized) {
17059 throw new Error("initializeWasm() must be awaited first!");
17061 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
17062 // debug statements here
17064 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
17066 export function LockedChannelMonitor_free(this_obj: number): void {
17067 if(!isWasmInitialized) {
17068 throw new Error("initializeWasm() must be awaited first!");
17070 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
17071 // debug statements here
17073 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
17075 export function ChainMonitor_free(this_obj: number): void {
17076 if(!isWasmInitialized) {
17077 throw new Error("initializeWasm() must be awaited first!");
17079 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
17080 // debug statements here
17082 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
17084 export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
17085 if(!isWasmInitialized) {
17086 throw new Error("initializeWasm() must be awaited first!");
17088 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
17089 return nativeResponseValue;
17091 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
17093 export function ChainMonitor_get_claimable_balances(this_arg: number, ignored_channels: number): number {
17094 if(!isWasmInitialized) {
17095 throw new Error("initializeWasm() must be awaited first!");
17097 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
17098 return nativeResponseValue;
17100 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
17102 export function ChainMonitor_get_monitor(this_arg: number, funding_txo: number): number {
17103 if(!isWasmInitialized) {
17104 throw new Error("initializeWasm() must be awaited first!");
17106 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
17107 return nativeResponseValue;
17109 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17111 export function ChainMonitor_list_monitors(this_arg: number): number {
17112 if(!isWasmInitialized) {
17113 throw new Error("initializeWasm() must be awaited first!");
17115 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
17116 return nativeResponseValue;
17118 // 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);
17120 export function ChainMonitor_channel_monitor_updated(this_arg: number, funding_txo: number, completed_update_id: number): number {
17121 if(!isWasmInitialized) {
17122 throw new Error("initializeWasm() must be awaited first!");
17124 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
17125 return nativeResponseValue;
17127 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17129 export function ChainMonitor_as_Listen(this_arg: number): number {
17130 if(!isWasmInitialized) {
17131 throw new Error("initializeWasm() must be awaited first!");
17133 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
17134 return nativeResponseValue;
17136 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17138 export function ChainMonitor_as_Confirm(this_arg: number): number {
17139 if(!isWasmInitialized) {
17140 throw new Error("initializeWasm() must be awaited first!");
17142 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
17143 return nativeResponseValue;
17145 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17147 export function ChainMonitor_as_Watch(this_arg: number): number {
17148 if(!isWasmInitialized) {
17149 throw new Error("initializeWasm() must be awaited first!");
17151 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
17152 return nativeResponseValue;
17154 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17156 export function ChainMonitor_as_EventsProvider(this_arg: number): number {
17157 if(!isWasmInitialized) {
17158 throw new Error("initializeWasm() must be awaited first!");
17160 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
17161 return nativeResponseValue;
17163 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
17165 export function ChannelMonitorUpdate_free(this_obj: number): void {
17166 if(!isWasmInitialized) {
17167 throw new Error("initializeWasm() must be awaited first!");
17169 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
17170 // debug statements here
17172 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
17174 export function ChannelMonitorUpdate_get_update_id(this_ptr: number): bigint {
17175 if(!isWasmInitialized) {
17176 throw new Error("initializeWasm() must be awaited first!");
17178 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
17179 return nativeResponseValue;
17181 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
17183 export function ChannelMonitorUpdate_set_update_id(this_ptr: number, val: bigint): void {
17184 if(!isWasmInitialized) {
17185 throw new Error("initializeWasm() must be awaited first!");
17187 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
17188 // debug statements here
17190 // uintptr_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
17192 export function ChannelMonitorUpdate_clone_ptr(arg: number): number {
17193 if(!isWasmInitialized) {
17194 throw new Error("initializeWasm() must be awaited first!");
17196 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
17197 return nativeResponseValue;
17199 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
17201 export function ChannelMonitorUpdate_clone(orig: number): number {
17202 if(!isWasmInitialized) {
17203 throw new Error("initializeWasm() must be awaited first!");
17205 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
17206 return nativeResponseValue;
17208 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
17210 export function ChannelMonitorUpdate_write(obj: number): number {
17211 if(!isWasmInitialized) {
17212 throw new Error("initializeWasm() must be awaited first!");
17214 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
17215 return nativeResponseValue;
17217 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
17219 export function ChannelMonitorUpdate_read(ser: number): number {
17220 if(!isWasmInitialized) {
17221 throw new Error("initializeWasm() must be awaited first!");
17223 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
17224 return nativeResponseValue;
17226 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
17228 export function MonitorEvent_free(this_ptr: number): void {
17229 if(!isWasmInitialized) {
17230 throw new Error("initializeWasm() must be awaited first!");
17232 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
17233 // debug statements here
17235 // uintptr_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
17237 export function MonitorEvent_clone_ptr(arg: number): number {
17238 if(!isWasmInitialized) {
17239 throw new Error("initializeWasm() must be awaited first!");
17241 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
17242 return nativeResponseValue;
17244 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
17246 export function MonitorEvent_clone(orig: number): number {
17247 if(!isWasmInitialized) {
17248 throw new Error("initializeWasm() must be awaited first!");
17250 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
17251 return nativeResponseValue;
17253 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
17255 export function MonitorEvent_htlcevent(a: number): number {
17256 if(!isWasmInitialized) {
17257 throw new Error("initializeWasm() must be awaited first!");
17259 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
17260 return nativeResponseValue;
17262 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
17264 export function MonitorEvent_commitment_tx_confirmed(a: number): number {
17265 if(!isWasmInitialized) {
17266 throw new Error("initializeWasm() must be awaited first!");
17268 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
17269 return nativeResponseValue;
17271 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
17273 export function MonitorEvent_update_completed(funding_txo: number, monitor_update_id: bigint): number {
17274 if(!isWasmInitialized) {
17275 throw new Error("initializeWasm() must be awaited first!");
17277 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
17278 return nativeResponseValue;
17280 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
17282 export function MonitorEvent_update_failed(a: number): number {
17283 if(!isWasmInitialized) {
17284 throw new Error("initializeWasm() must be awaited first!");
17286 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
17287 return nativeResponseValue;
17289 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
17291 export function MonitorEvent_write(obj: number): number {
17292 if(!isWasmInitialized) {
17293 throw new Error("initializeWasm() must be awaited first!");
17295 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
17296 return nativeResponseValue;
17298 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
17300 export function MonitorEvent_read(ser: number): number {
17301 if(!isWasmInitialized) {
17302 throw new Error("initializeWasm() must be awaited first!");
17304 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
17305 return nativeResponseValue;
17307 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
17309 export function HTLCUpdate_free(this_obj: number): void {
17310 if(!isWasmInitialized) {
17311 throw new Error("initializeWasm() must be awaited first!");
17313 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
17314 // debug statements here
17316 // uintptr_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
17318 export function HTLCUpdate_clone_ptr(arg: number): number {
17319 if(!isWasmInitialized) {
17320 throw new Error("initializeWasm() must be awaited first!");
17322 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
17323 return nativeResponseValue;
17325 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
17327 export function HTLCUpdate_clone(orig: number): number {
17328 if(!isWasmInitialized) {
17329 throw new Error("initializeWasm() must be awaited first!");
17331 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
17332 return nativeResponseValue;
17334 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
17336 export function HTLCUpdate_write(obj: number): number {
17337 if(!isWasmInitialized) {
17338 throw new Error("initializeWasm() must be awaited first!");
17340 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
17341 return nativeResponseValue;
17343 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
17345 export function HTLCUpdate_read(ser: number): number {
17346 if(!isWasmInitialized) {
17347 throw new Error("initializeWasm() must be awaited first!");
17349 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
17350 return nativeResponseValue;
17352 // void Balance_free(struct LDKBalance this_ptr);
17354 export function Balance_free(this_ptr: number): void {
17355 if(!isWasmInitialized) {
17356 throw new Error("initializeWasm() must be awaited first!");
17358 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
17359 // debug statements here
17361 // uintptr_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
17363 export function Balance_clone_ptr(arg: number): number {
17364 if(!isWasmInitialized) {
17365 throw new Error("initializeWasm() must be awaited first!");
17367 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
17368 return nativeResponseValue;
17370 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
17372 export function Balance_clone(orig: number): number {
17373 if(!isWasmInitialized) {
17374 throw new Error("initializeWasm() must be awaited first!");
17376 const nativeResponseValue = wasm.TS_Balance_clone(orig);
17377 return nativeResponseValue;
17379 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
17381 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): number {
17382 if(!isWasmInitialized) {
17383 throw new Error("initializeWasm() must be awaited first!");
17385 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
17386 return nativeResponseValue;
17388 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
17390 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): number {
17391 if(!isWasmInitialized) {
17392 throw new Error("initializeWasm() must be awaited first!");
17394 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
17395 return nativeResponseValue;
17397 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
17399 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): number {
17400 if(!isWasmInitialized) {
17401 throw new Error("initializeWasm() must be awaited first!");
17403 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
17404 return nativeResponseValue;
17406 // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
17408 export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: bigint, claimable_height: number): number {
17409 if(!isWasmInitialized) {
17410 throw new Error("initializeWasm() must be awaited first!");
17412 const nativeResponseValue = wasm.TS_Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
17413 return nativeResponseValue;
17415 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
17417 export function Balance_eq(a: number, b: number): boolean {
17418 if(!isWasmInitialized) {
17419 throw new Error("initializeWasm() must be awaited first!");
17421 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
17422 return nativeResponseValue;
17424 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
17426 export function ChannelMonitor_free(this_obj: number): void {
17427 if(!isWasmInitialized) {
17428 throw new Error("initializeWasm() must be awaited first!");
17430 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
17431 // debug statements here
17433 // uintptr_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
17435 export function ChannelMonitor_clone_ptr(arg: number): number {
17436 if(!isWasmInitialized) {
17437 throw new Error("initializeWasm() must be awaited first!");
17439 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
17440 return nativeResponseValue;
17442 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
17444 export function ChannelMonitor_clone(orig: number): number {
17445 if(!isWasmInitialized) {
17446 throw new Error("initializeWasm() must be awaited first!");
17448 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
17449 return nativeResponseValue;
17451 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
17453 export function ChannelMonitor_write(obj: number): number {
17454 if(!isWasmInitialized) {
17455 throw new Error("initializeWasm() must be awaited first!");
17457 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
17458 return nativeResponseValue;
17460 // MUST_USE_RES struct LDKCResult_NoneNoneZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger);
17462 export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
17463 if(!isWasmInitialized) {
17464 throw new Error("initializeWasm() must be awaited first!");
17466 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
17467 return nativeResponseValue;
17469 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17471 export function ChannelMonitor_get_latest_update_id(this_arg: number): bigint {
17472 if(!isWasmInitialized) {
17473 throw new Error("initializeWasm() must be awaited first!");
17475 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
17476 return nativeResponseValue;
17478 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17480 export function ChannelMonitor_get_funding_txo(this_arg: number): number {
17481 if(!isWasmInitialized) {
17482 throw new Error("initializeWasm() must be awaited first!");
17484 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
17485 return nativeResponseValue;
17487 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17489 export function ChannelMonitor_get_outputs_to_watch(this_arg: number): number {
17490 if(!isWasmInitialized) {
17491 throw new Error("initializeWasm() must be awaited first!");
17493 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
17494 return nativeResponseValue;
17496 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
17498 export function ChannelMonitor_load_outputs_to_watch(this_arg: number, filter: number): void {
17499 if(!isWasmInitialized) {
17500 throw new Error("initializeWasm() must be awaited first!");
17502 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
17503 // debug statements here
17505 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17507 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number {
17508 if(!isWasmInitialized) {
17509 throw new Error("initializeWasm() must be awaited first!");
17511 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
17512 return nativeResponseValue;
17514 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17516 export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number {
17517 if(!isWasmInitialized) {
17518 throw new Error("initializeWasm() must be awaited first!");
17520 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
17521 return nativeResponseValue;
17523 // 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);
17525 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): number {
17526 if(!isWasmInitialized) {
17527 throw new Error("initializeWasm() must be awaited first!");
17529 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
17530 return nativeResponseValue;
17532 // 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);
17534 export function ChannelMonitor_block_connected(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17535 if(!isWasmInitialized) {
17536 throw new Error("initializeWasm() must be awaited first!");
17538 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
17539 return nativeResponseValue;
17541 // 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);
17543 export function ChannelMonitor_block_disconnected(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
17544 if(!isWasmInitialized) {
17545 throw new Error("initializeWasm() must be awaited first!");
17547 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
17548 // debug statements here
17550 // 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);
17552 export function ChannelMonitor_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17553 if(!isWasmInitialized) {
17554 throw new Error("initializeWasm() must be awaited first!");
17556 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
17557 return nativeResponseValue;
17559 // 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);
17561 export function ChannelMonitor_transaction_unconfirmed(this_arg: number, txid: number, broadcaster: number, fee_estimator: number, logger: number): void {
17562 if(!isWasmInitialized) {
17563 throw new Error("initializeWasm() must be awaited first!");
17565 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
17566 // debug statements here
17568 // 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);
17570 export function ChannelMonitor_best_block_updated(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17571 if(!isWasmInitialized) {
17572 throw new Error("initializeWasm() must be awaited first!");
17574 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
17575 return nativeResponseValue;
17577 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17579 export function ChannelMonitor_get_relevant_txids(this_arg: number): number {
17580 if(!isWasmInitialized) {
17581 throw new Error("initializeWasm() must be awaited first!");
17583 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
17584 return nativeResponseValue;
17586 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17588 export function ChannelMonitor_current_best_block(this_arg: number): number {
17589 if(!isWasmInitialized) {
17590 throw new Error("initializeWasm() must be awaited first!");
17592 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
17593 return nativeResponseValue;
17595 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17597 export function ChannelMonitor_get_claimable_balances(this_arg: number): number {
17598 if(!isWasmInitialized) {
17599 throw new Error("initializeWasm() must be awaited first!");
17601 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
17602 return nativeResponseValue;
17604 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
17606 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: number): number {
17607 if(!isWasmInitialized) {
17608 throw new Error("initializeWasm() must be awaited first!");
17610 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
17611 return nativeResponseValue;
17613 // void OutPoint_free(struct LDKOutPoint this_obj);
17615 export function OutPoint_free(this_obj: number): void {
17616 if(!isWasmInitialized) {
17617 throw new Error("initializeWasm() must be awaited first!");
17619 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
17620 // debug statements here
17622 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
17624 export function OutPoint_get_txid(this_ptr: number): number {
17625 if(!isWasmInitialized) {
17626 throw new Error("initializeWasm() must be awaited first!");
17628 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
17629 return nativeResponseValue;
17631 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17633 export function OutPoint_set_txid(this_ptr: number, val: number): void {
17634 if(!isWasmInitialized) {
17635 throw new Error("initializeWasm() must be awaited first!");
17637 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
17638 // debug statements here
17640 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
17642 export function OutPoint_get_index(this_ptr: number): number {
17643 if(!isWasmInitialized) {
17644 throw new Error("initializeWasm() must be awaited first!");
17646 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
17647 return nativeResponseValue;
17649 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
17651 export function OutPoint_set_index(this_ptr: number, val: number): void {
17652 if(!isWasmInitialized) {
17653 throw new Error("initializeWasm() must be awaited first!");
17655 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
17656 // debug statements here
17658 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
17660 export function OutPoint_new(txid_arg: number, index_arg: number): number {
17661 if(!isWasmInitialized) {
17662 throw new Error("initializeWasm() must be awaited first!");
17664 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
17665 return nativeResponseValue;
17667 // uintptr_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
17669 export function OutPoint_clone_ptr(arg: number): number {
17670 if(!isWasmInitialized) {
17671 throw new Error("initializeWasm() must be awaited first!");
17673 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
17674 return nativeResponseValue;
17676 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
17678 export function OutPoint_clone(orig: number): number {
17679 if(!isWasmInitialized) {
17680 throw new Error("initializeWasm() must be awaited first!");
17682 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
17683 return nativeResponseValue;
17685 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
17687 export function OutPoint_eq(a: number, b: number): boolean {
17688 if(!isWasmInitialized) {
17689 throw new Error("initializeWasm() must be awaited first!");
17691 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
17692 return nativeResponseValue;
17694 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
17696 export function OutPoint_hash(o: number): bigint {
17697 if(!isWasmInitialized) {
17698 throw new Error("initializeWasm() must be awaited first!");
17700 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
17701 return nativeResponseValue;
17703 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
17705 export function OutPoint_to_channel_id(this_arg: number): number {
17706 if(!isWasmInitialized) {
17707 throw new Error("initializeWasm() must be awaited first!");
17709 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
17710 return nativeResponseValue;
17712 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
17714 export function OutPoint_write(obj: number): number {
17715 if(!isWasmInitialized) {
17716 throw new Error("initializeWasm() must be awaited first!");
17718 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
17719 return nativeResponseValue;
17721 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
17723 export function OutPoint_read(ser: number): number {
17724 if(!isWasmInitialized) {
17725 throw new Error("initializeWasm() must be awaited first!");
17727 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
17728 return nativeResponseValue;
17730 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
17732 export function DelayedPaymentOutputDescriptor_free(this_obj: number): void {
17733 if(!isWasmInitialized) {
17734 throw new Error("initializeWasm() must be awaited first!");
17736 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
17737 // debug statements here
17739 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17741 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
17742 if(!isWasmInitialized) {
17743 throw new Error("initializeWasm() must be awaited first!");
17745 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
17746 return nativeResponseValue;
17748 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17750 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
17751 if(!isWasmInitialized) {
17752 throw new Error("initializeWasm() must be awaited first!");
17754 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
17755 // debug statements here
17757 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17759 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): number {
17760 if(!isWasmInitialized) {
17761 throw new Error("initializeWasm() must be awaited first!");
17763 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
17764 return nativeResponseValue;
17766 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17768 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: number, val: number): void {
17769 if(!isWasmInitialized) {
17770 throw new Error("initializeWasm() must be awaited first!");
17772 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
17773 // debug statements here
17775 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17777 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number {
17778 if(!isWasmInitialized) {
17779 throw new Error("initializeWasm() must be awaited first!");
17781 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
17782 return nativeResponseValue;
17784 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
17786 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: number, val: number): void {
17787 if(!isWasmInitialized) {
17788 throw new Error("initializeWasm() must be awaited first!");
17790 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
17791 // debug statements here
17793 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
17795 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
17796 if(!isWasmInitialized) {
17797 throw new Error("initializeWasm() must be awaited first!");
17799 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
17800 // debug statements here
17802 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17804 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): number {
17805 if(!isWasmInitialized) {
17806 throw new Error("initializeWasm() must be awaited first!");
17808 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
17809 return nativeResponseValue;
17811 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17813 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: number, val: number): void {
17814 if(!isWasmInitialized) {
17815 throw new Error("initializeWasm() must be awaited first!");
17817 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
17818 // debug statements here
17820 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
17822 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
17823 if(!isWasmInitialized) {
17824 throw new Error("initializeWasm() must be awaited first!");
17826 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
17827 return nativeResponseValue;
17829 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17831 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
17832 if(!isWasmInitialized) {
17833 throw new Error("initializeWasm() must be awaited first!");
17835 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
17836 // debug statements here
17838 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17840 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
17841 if(!isWasmInitialized) {
17842 throw new Error("initializeWasm() must be awaited first!");
17844 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
17845 return nativeResponseValue;
17847 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
17849 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
17850 if(!isWasmInitialized) {
17851 throw new Error("initializeWasm() must be awaited first!");
17853 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
17854 // debug statements here
17856 // 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);
17858 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 {
17859 if(!isWasmInitialized) {
17860 throw new Error("initializeWasm() must be awaited first!");
17862 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);
17863 return nativeResponseValue;
17865 // uintptr_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
17867 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: number): number {
17868 if(!isWasmInitialized) {
17869 throw new Error("initializeWasm() must be awaited first!");
17871 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
17872 return nativeResponseValue;
17874 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
17876 export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
17877 if(!isWasmInitialized) {
17878 throw new Error("initializeWasm() must be awaited first!");
17880 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
17881 return nativeResponseValue;
17883 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
17885 export function DelayedPaymentOutputDescriptor_write(obj: number): number {
17886 if(!isWasmInitialized) {
17887 throw new Error("initializeWasm() must be awaited first!");
17889 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
17890 return nativeResponseValue;
17892 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
17894 export function DelayedPaymentOutputDescriptor_read(ser: number): number {
17895 if(!isWasmInitialized) {
17896 throw new Error("initializeWasm() must be awaited first!");
17898 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
17899 return nativeResponseValue;
17901 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
17903 export function StaticPaymentOutputDescriptor_free(this_obj: number): void {
17904 if(!isWasmInitialized) {
17905 throw new Error("initializeWasm() must be awaited first!");
17907 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
17908 // debug statements here
17910 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17912 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
17913 if(!isWasmInitialized) {
17914 throw new Error("initializeWasm() must be awaited first!");
17916 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
17917 return nativeResponseValue;
17919 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17921 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
17922 if(!isWasmInitialized) {
17923 throw new Error("initializeWasm() must be awaited first!");
17925 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
17926 // debug statements here
17928 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
17930 export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
17931 if(!isWasmInitialized) {
17932 throw new Error("initializeWasm() must be awaited first!");
17934 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
17935 // debug statements here
17937 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
17939 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
17940 if(!isWasmInitialized) {
17941 throw new Error("initializeWasm() must be awaited first!");
17943 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
17944 return nativeResponseValue;
17946 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17948 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
17949 if(!isWasmInitialized) {
17950 throw new Error("initializeWasm() must be awaited first!");
17952 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
17953 // debug statements here
17955 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17957 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
17958 if(!isWasmInitialized) {
17959 throw new Error("initializeWasm() must be awaited first!");
17961 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
17962 return nativeResponseValue;
17964 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
17966 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
17967 if(!isWasmInitialized) {
17968 throw new Error("initializeWasm() must be awaited first!");
17970 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
17971 // debug statements here
17973 // 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);
17975 export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
17976 if(!isWasmInitialized) {
17977 throw new Error("initializeWasm() must be awaited first!");
17979 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
17980 return nativeResponseValue;
17982 // uintptr_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
17984 export function StaticPaymentOutputDescriptor_clone_ptr(arg: number): number {
17985 if(!isWasmInitialized) {
17986 throw new Error("initializeWasm() must be awaited first!");
17988 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
17989 return nativeResponseValue;
17991 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
17993 export function StaticPaymentOutputDescriptor_clone(orig: number): number {
17994 if(!isWasmInitialized) {
17995 throw new Error("initializeWasm() must be awaited first!");
17997 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
17998 return nativeResponseValue;
18000 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
18002 export function StaticPaymentOutputDescriptor_write(obj: number): number {
18003 if(!isWasmInitialized) {
18004 throw new Error("initializeWasm() must be awaited first!");
18006 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
18007 return nativeResponseValue;
18009 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
18011 export function StaticPaymentOutputDescriptor_read(ser: number): number {
18012 if(!isWasmInitialized) {
18013 throw new Error("initializeWasm() must be awaited first!");
18015 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
18016 return nativeResponseValue;
18018 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
18020 export function SpendableOutputDescriptor_free(this_ptr: number): void {
18021 if(!isWasmInitialized) {
18022 throw new Error("initializeWasm() must be awaited first!");
18024 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
18025 // debug statements here
18027 // uintptr_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
18029 export function SpendableOutputDescriptor_clone_ptr(arg: number): number {
18030 if(!isWasmInitialized) {
18031 throw new Error("initializeWasm() must be awaited first!");
18033 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
18034 return nativeResponseValue;
18036 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
18038 export function SpendableOutputDescriptor_clone(orig: number): number {
18039 if(!isWasmInitialized) {
18040 throw new Error("initializeWasm() must be awaited first!");
18042 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
18043 return nativeResponseValue;
18045 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
18047 export function SpendableOutputDescriptor_static_output(outpoint: number, output: number): number {
18048 if(!isWasmInitialized) {
18049 throw new Error("initializeWasm() must be awaited first!");
18051 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
18052 return nativeResponseValue;
18054 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
18056 export function SpendableOutputDescriptor_delayed_payment_output(a: number): number {
18057 if(!isWasmInitialized) {
18058 throw new Error("initializeWasm() must be awaited first!");
18060 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
18061 return nativeResponseValue;
18063 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
18065 export function SpendableOutputDescriptor_static_payment_output(a: number): number {
18066 if(!isWasmInitialized) {
18067 throw new Error("initializeWasm() must be awaited first!");
18069 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
18070 return nativeResponseValue;
18072 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
18074 export function SpendableOutputDescriptor_write(obj: number): number {
18075 if(!isWasmInitialized) {
18076 throw new Error("initializeWasm() must be awaited first!");
18078 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
18079 return nativeResponseValue;
18081 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
18083 export function SpendableOutputDescriptor_read(ser: number): number {
18084 if(!isWasmInitialized) {
18085 throw new Error("initializeWasm() must be awaited first!");
18087 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
18088 return nativeResponseValue;
18090 // void BaseSign_free(struct LDKBaseSign this_ptr);
18092 export function BaseSign_free(this_ptr: number): void {
18093 if(!isWasmInitialized) {
18094 throw new Error("initializeWasm() must be awaited first!");
18096 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
18097 // debug statements here
18099 // uintptr_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
18101 export function Sign_clone_ptr(arg: number): number {
18102 if(!isWasmInitialized) {
18103 throw new Error("initializeWasm() must be awaited first!");
18105 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
18106 return nativeResponseValue;
18108 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
18110 export function Sign_clone(orig: number): number {
18111 if(!isWasmInitialized) {
18112 throw new Error("initializeWasm() must be awaited first!");
18114 const nativeResponseValue = wasm.TS_Sign_clone(orig);
18115 return nativeResponseValue;
18117 // void Sign_free(struct LDKSign this_ptr);
18119 export function Sign_free(this_ptr: number): void {
18120 if(!isWasmInitialized) {
18121 throw new Error("initializeWasm() must be awaited first!");
18123 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
18124 // debug statements here
18126 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
18128 export function Recipient_clone(orig: number): Recipient {
18129 if(!isWasmInitialized) {
18130 throw new Error("initializeWasm() must be awaited first!");
18132 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
18133 return nativeResponseValue;
18135 // enum LDKRecipient Recipient_node(void);
18137 export function Recipient_node(): Recipient {
18138 if(!isWasmInitialized) {
18139 throw new Error("initializeWasm() must be awaited first!");
18141 const nativeResponseValue = wasm.TS_Recipient_node();
18142 return nativeResponseValue;
18144 // enum LDKRecipient Recipient_phantom_node(void);
18146 export function Recipient_phantom_node(): Recipient {
18147 if(!isWasmInitialized) {
18148 throw new Error("initializeWasm() must be awaited first!");
18150 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
18151 return nativeResponseValue;
18153 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
18155 export function KeysInterface_free(this_ptr: number): void {
18156 if(!isWasmInitialized) {
18157 throw new Error("initializeWasm() must be awaited first!");
18159 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
18160 // debug statements here
18162 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
18164 export function InMemorySigner_free(this_obj: number): void {
18165 if(!isWasmInitialized) {
18166 throw new Error("initializeWasm() must be awaited first!");
18168 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
18169 // debug statements here
18171 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18173 export function InMemorySigner_get_funding_key(this_ptr: number): number {
18174 if(!isWasmInitialized) {
18175 throw new Error("initializeWasm() must be awaited first!");
18177 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
18178 return nativeResponseValue;
18180 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18182 export function InMemorySigner_set_funding_key(this_ptr: number, val: number): void {
18183 if(!isWasmInitialized) {
18184 throw new Error("initializeWasm() must be awaited first!");
18186 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
18187 // debug statements here
18189 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18191 export function InMemorySigner_get_revocation_base_key(this_ptr: number): number {
18192 if(!isWasmInitialized) {
18193 throw new Error("initializeWasm() must be awaited first!");
18195 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
18196 return nativeResponseValue;
18198 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18200 export function InMemorySigner_set_revocation_base_key(this_ptr: number, val: number): void {
18201 if(!isWasmInitialized) {
18202 throw new Error("initializeWasm() must be awaited first!");
18204 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
18205 // debug statements here
18207 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18209 export function InMemorySigner_get_payment_key(this_ptr: number): number {
18210 if(!isWasmInitialized) {
18211 throw new Error("initializeWasm() must be awaited first!");
18213 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
18214 return nativeResponseValue;
18216 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18218 export function InMemorySigner_set_payment_key(this_ptr: number, val: number): void {
18219 if(!isWasmInitialized) {
18220 throw new Error("initializeWasm() must be awaited first!");
18222 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
18223 // debug statements here
18225 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18227 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): number {
18228 if(!isWasmInitialized) {
18229 throw new Error("initializeWasm() must be awaited first!");
18231 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
18232 return nativeResponseValue;
18234 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18236 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: number, val: number): void {
18237 if(!isWasmInitialized) {
18238 throw new Error("initializeWasm() must be awaited first!");
18240 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
18241 // debug statements here
18243 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18245 export function InMemorySigner_get_htlc_base_key(this_ptr: number): number {
18246 if(!isWasmInitialized) {
18247 throw new Error("initializeWasm() must be awaited first!");
18249 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
18250 return nativeResponseValue;
18252 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18254 export function InMemorySigner_set_htlc_base_key(this_ptr: number, val: number): void {
18255 if(!isWasmInitialized) {
18256 throw new Error("initializeWasm() must be awaited first!");
18258 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
18259 // debug statements here
18261 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18263 export function InMemorySigner_get_commitment_seed(this_ptr: number): number {
18264 if(!isWasmInitialized) {
18265 throw new Error("initializeWasm() must be awaited first!");
18267 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
18268 return nativeResponseValue;
18270 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18272 export function InMemorySigner_set_commitment_seed(this_ptr: number, val: number): void {
18273 if(!isWasmInitialized) {
18274 throw new Error("initializeWasm() must be awaited first!");
18276 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
18277 // debug statements here
18279 // uintptr_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
18281 export function InMemorySigner_clone_ptr(arg: number): number {
18282 if(!isWasmInitialized) {
18283 throw new Error("initializeWasm() must be awaited first!");
18285 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
18286 return nativeResponseValue;
18288 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
18290 export function InMemorySigner_clone(orig: number): number {
18291 if(!isWasmInitialized) {
18292 throw new Error("initializeWasm() must be awaited first!");
18294 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
18295 return nativeResponseValue;
18297 // 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);
18299 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 {
18300 if(!isWasmInitialized) {
18301 throw new Error("initializeWasm() must be awaited first!");
18303 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);
18304 return nativeResponseValue;
18306 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18308 export function InMemorySigner_counterparty_pubkeys(this_arg: number): number {
18309 if(!isWasmInitialized) {
18310 throw new Error("initializeWasm() must be awaited first!");
18312 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
18313 return nativeResponseValue;
18315 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18317 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number {
18318 if(!isWasmInitialized) {
18319 throw new Error("initializeWasm() must be awaited first!");
18321 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
18322 return nativeResponseValue;
18324 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18326 export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number {
18327 if(!isWasmInitialized) {
18328 throw new Error("initializeWasm() must be awaited first!");
18330 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
18331 return nativeResponseValue;
18333 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18335 export function InMemorySigner_is_outbound(this_arg: number): boolean {
18336 if(!isWasmInitialized) {
18337 throw new Error("initializeWasm() must be awaited first!");
18339 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
18340 return nativeResponseValue;
18342 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18344 export function InMemorySigner_funding_outpoint(this_arg: number): number {
18345 if(!isWasmInitialized) {
18346 throw new Error("initializeWasm() must be awaited first!");
18348 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
18349 return nativeResponseValue;
18351 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18353 export function InMemorySigner_get_channel_parameters(this_arg: number): number {
18354 if(!isWasmInitialized) {
18355 throw new Error("initializeWasm() must be awaited first!");
18357 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
18358 return nativeResponseValue;
18360 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18362 export function InMemorySigner_opt_anchors(this_arg: number): boolean {
18363 if(!isWasmInitialized) {
18364 throw new Error("initializeWasm() must be awaited first!");
18366 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
18367 return nativeResponseValue;
18369 // 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);
18371 export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
18372 if(!isWasmInitialized) {
18373 throw new Error("initializeWasm() must be awaited first!");
18375 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
18376 return nativeResponseValue;
18378 // 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);
18380 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
18381 if(!isWasmInitialized) {
18382 throw new Error("initializeWasm() must be awaited first!");
18384 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
18385 return nativeResponseValue;
18387 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18389 export function InMemorySigner_as_BaseSign(this_arg: number): number {
18390 if(!isWasmInitialized) {
18391 throw new Error("initializeWasm() must be awaited first!");
18393 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
18394 return nativeResponseValue;
18396 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18398 export function InMemorySigner_as_Sign(this_arg: number): number {
18399 if(!isWasmInitialized) {
18400 throw new Error("initializeWasm() must be awaited first!");
18402 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
18403 return nativeResponseValue;
18405 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
18407 export function InMemorySigner_write(obj: number): number {
18408 if(!isWasmInitialized) {
18409 throw new Error("initializeWasm() must be awaited first!");
18411 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
18412 return nativeResponseValue;
18414 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
18416 export function InMemorySigner_read(ser: number, arg: number): number {
18417 if(!isWasmInitialized) {
18418 throw new Error("initializeWasm() must be awaited first!");
18420 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
18421 return nativeResponseValue;
18423 // void KeysManager_free(struct LDKKeysManager this_obj);
18425 export function KeysManager_free(this_obj: number): void {
18426 if(!isWasmInitialized) {
18427 throw new Error("initializeWasm() must be awaited first!");
18429 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
18430 // debug statements here
18432 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
18434 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): number {
18435 if(!isWasmInitialized) {
18436 throw new Error("initializeWasm() must be awaited first!");
18438 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
18439 return nativeResponseValue;
18441 // 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]);
18443 export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
18444 if(!isWasmInitialized) {
18445 throw new Error("initializeWasm() must be awaited first!");
18447 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
18448 return nativeResponseValue;
18450 // 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);
18452 export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
18453 if(!isWasmInitialized) {
18454 throw new Error("initializeWasm() must be awaited first!");
18456 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
18457 return nativeResponseValue;
18459 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
18461 export function KeysManager_as_KeysInterface(this_arg: number): number {
18462 if(!isWasmInitialized) {
18463 throw new Error("initializeWasm() must be awaited first!");
18465 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
18466 return nativeResponseValue;
18468 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
18470 export function PhantomKeysManager_free(this_obj: number): void {
18471 if(!isWasmInitialized) {
18472 throw new Error("initializeWasm() must be awaited first!");
18474 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
18475 // debug statements here
18477 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
18479 export function PhantomKeysManager_as_KeysInterface(this_arg: number): number {
18480 if(!isWasmInitialized) {
18481 throw new Error("initializeWasm() must be awaited first!");
18483 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
18484 return nativeResponseValue;
18486 // 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]);
18488 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): number {
18489 if(!isWasmInitialized) {
18490 throw new Error("initializeWasm() must be awaited first!");
18492 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
18493 return nativeResponseValue;
18495 // 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);
18497 export function PhantomKeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
18498 if(!isWasmInitialized) {
18499 throw new Error("initializeWasm() must be awaited first!");
18501 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
18502 return nativeResponseValue;
18504 // 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]);
18506 export function PhantomKeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
18507 if(!isWasmInitialized) {
18508 throw new Error("initializeWasm() must be awaited first!");
18510 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
18511 return nativeResponseValue;
18513 // void ChannelManager_free(struct LDKChannelManager this_obj);
18515 export function ChannelManager_free(this_obj: number): void {
18516 if(!isWasmInitialized) {
18517 throw new Error("initializeWasm() must be awaited first!");
18519 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
18520 // debug statements here
18522 // void ChainParameters_free(struct LDKChainParameters this_obj);
18524 export function ChainParameters_free(this_obj: number): void {
18525 if(!isWasmInitialized) {
18526 throw new Error("initializeWasm() must be awaited first!");
18528 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
18529 // debug statements here
18531 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
18533 export function ChainParameters_get_network(this_ptr: number): Network {
18534 if(!isWasmInitialized) {
18535 throw new Error("initializeWasm() must be awaited first!");
18537 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
18538 return nativeResponseValue;
18540 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
18542 export function ChainParameters_set_network(this_ptr: number, val: Network): void {
18543 if(!isWasmInitialized) {
18544 throw new Error("initializeWasm() must be awaited first!");
18546 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
18547 // debug statements here
18549 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
18551 export function ChainParameters_get_best_block(this_ptr: number): number {
18552 if(!isWasmInitialized) {
18553 throw new Error("initializeWasm() must be awaited first!");
18555 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
18556 return nativeResponseValue;
18558 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
18560 export function ChainParameters_set_best_block(this_ptr: number, val: number): void {
18561 if(!isWasmInitialized) {
18562 throw new Error("initializeWasm() must be awaited first!");
18564 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
18565 // debug statements here
18567 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
18569 export function ChainParameters_new(network_arg: Network, best_block_arg: number): number {
18570 if(!isWasmInitialized) {
18571 throw new Error("initializeWasm() must be awaited first!");
18573 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
18574 return nativeResponseValue;
18576 // uintptr_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
18578 export function ChainParameters_clone_ptr(arg: number): number {
18579 if(!isWasmInitialized) {
18580 throw new Error("initializeWasm() must be awaited first!");
18582 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
18583 return nativeResponseValue;
18585 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
18587 export function ChainParameters_clone(orig: number): number {
18588 if(!isWasmInitialized) {
18589 throw new Error("initializeWasm() must be awaited first!");
18591 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
18592 return nativeResponseValue;
18594 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
18596 export function CounterpartyForwardingInfo_free(this_obj: number): void {
18597 if(!isWasmInitialized) {
18598 throw new Error("initializeWasm() must be awaited first!");
18600 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
18601 // debug statements here
18603 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18605 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: number): number {
18606 if(!isWasmInitialized) {
18607 throw new Error("initializeWasm() must be awaited first!");
18609 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
18610 return nativeResponseValue;
18612 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
18614 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: number, val: number): void {
18615 if(!isWasmInitialized) {
18616 throw new Error("initializeWasm() must be awaited first!");
18618 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
18619 // debug statements here
18621 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18623 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: number): number {
18624 if(!isWasmInitialized) {
18625 throw new Error("initializeWasm() must be awaited first!");
18627 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
18628 return nativeResponseValue;
18630 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
18632 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: number, val: number): void {
18633 if(!isWasmInitialized) {
18634 throw new Error("initializeWasm() must be awaited first!");
18636 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
18637 // debug statements here
18639 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18641 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: number): number {
18642 if(!isWasmInitialized) {
18643 throw new Error("initializeWasm() must be awaited first!");
18645 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
18646 return nativeResponseValue;
18648 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
18650 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
18651 if(!isWasmInitialized) {
18652 throw new Error("initializeWasm() must be awaited first!");
18654 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
18655 // debug statements here
18657 // 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);
18659 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): number {
18660 if(!isWasmInitialized) {
18661 throw new Error("initializeWasm() must be awaited first!");
18663 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
18664 return nativeResponseValue;
18666 // uintptr_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
18668 export function CounterpartyForwardingInfo_clone_ptr(arg: number): number {
18669 if(!isWasmInitialized) {
18670 throw new Error("initializeWasm() must be awaited first!");
18672 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
18673 return nativeResponseValue;
18675 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
18677 export function CounterpartyForwardingInfo_clone(orig: number): number {
18678 if(!isWasmInitialized) {
18679 throw new Error("initializeWasm() must be awaited first!");
18681 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
18682 return nativeResponseValue;
18684 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
18686 export function ChannelCounterparty_free(this_obj: number): void {
18687 if(!isWasmInitialized) {
18688 throw new Error("initializeWasm() must be awaited first!");
18690 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
18691 // debug statements here
18693 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18695 export function ChannelCounterparty_get_node_id(this_ptr: number): number {
18696 if(!isWasmInitialized) {
18697 throw new Error("initializeWasm() must be awaited first!");
18699 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
18700 return nativeResponseValue;
18702 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18704 export function ChannelCounterparty_set_node_id(this_ptr: number, val: number): void {
18705 if(!isWasmInitialized) {
18706 throw new Error("initializeWasm() must be awaited first!");
18708 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
18709 // debug statements here
18711 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18713 export function ChannelCounterparty_get_features(this_ptr: number): number {
18714 if(!isWasmInitialized) {
18715 throw new Error("initializeWasm() must be awaited first!");
18717 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
18718 return nativeResponseValue;
18720 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
18722 export function ChannelCounterparty_set_features(this_ptr: number, val: number): void {
18723 if(!isWasmInitialized) {
18724 throw new Error("initializeWasm() must be awaited first!");
18726 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
18727 // debug statements here
18729 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18731 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: number): bigint {
18732 if(!isWasmInitialized) {
18733 throw new Error("initializeWasm() must be awaited first!");
18735 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
18736 return nativeResponseValue;
18738 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
18740 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: number, val: bigint): void {
18741 if(!isWasmInitialized) {
18742 throw new Error("initializeWasm() must be awaited first!");
18744 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
18745 // debug statements here
18747 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18749 export function ChannelCounterparty_get_forwarding_info(this_ptr: number): number {
18750 if(!isWasmInitialized) {
18751 throw new Error("initializeWasm() must be awaited first!");
18753 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
18754 return nativeResponseValue;
18756 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
18758 export function ChannelCounterparty_set_forwarding_info(this_ptr: number, val: number): void {
18759 if(!isWasmInitialized) {
18760 throw new Error("initializeWasm() must be awaited first!");
18762 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
18763 // debug statements here
18765 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18767 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: number): number {
18768 if(!isWasmInitialized) {
18769 throw new Error("initializeWasm() must be awaited first!");
18771 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
18772 return nativeResponseValue;
18774 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18776 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: number, val: number): void {
18777 if(!isWasmInitialized) {
18778 throw new Error("initializeWasm() must be awaited first!");
18780 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
18781 // debug statements here
18783 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18785 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: number): number {
18786 if(!isWasmInitialized) {
18787 throw new Error("initializeWasm() must be awaited first!");
18789 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
18790 return nativeResponseValue;
18792 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18794 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: number, val: number): void {
18795 if(!isWasmInitialized) {
18796 throw new Error("initializeWasm() must be awaited first!");
18798 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
18799 // debug statements here
18801 // 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);
18803 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 {
18804 if(!isWasmInitialized) {
18805 throw new Error("initializeWasm() must be awaited first!");
18807 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);
18808 return nativeResponseValue;
18810 // uintptr_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
18812 export function ChannelCounterparty_clone_ptr(arg: number): number {
18813 if(!isWasmInitialized) {
18814 throw new Error("initializeWasm() must be awaited first!");
18816 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
18817 return nativeResponseValue;
18819 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
18821 export function ChannelCounterparty_clone(orig: number): number {
18822 if(!isWasmInitialized) {
18823 throw new Error("initializeWasm() must be awaited first!");
18825 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
18826 return nativeResponseValue;
18828 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
18830 export function ChannelDetails_free(this_obj: number): void {
18831 if(!isWasmInitialized) {
18832 throw new Error("initializeWasm() must be awaited first!");
18834 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
18835 // debug statements here
18837 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
18839 export function ChannelDetails_get_channel_id(this_ptr: number): number {
18840 if(!isWasmInitialized) {
18841 throw new Error("initializeWasm() must be awaited first!");
18843 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
18844 return nativeResponseValue;
18846 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18848 export function ChannelDetails_set_channel_id(this_ptr: number, val: number): void {
18849 if(!isWasmInitialized) {
18850 throw new Error("initializeWasm() must be awaited first!");
18852 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
18853 // debug statements here
18855 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18857 export function ChannelDetails_get_counterparty(this_ptr: number): number {
18858 if(!isWasmInitialized) {
18859 throw new Error("initializeWasm() must be awaited first!");
18861 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
18862 return nativeResponseValue;
18864 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
18866 export function ChannelDetails_set_counterparty(this_ptr: number, val: number): void {
18867 if(!isWasmInitialized) {
18868 throw new Error("initializeWasm() must be awaited first!");
18870 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
18871 // debug statements here
18873 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18875 export function ChannelDetails_get_funding_txo(this_ptr: number): number {
18876 if(!isWasmInitialized) {
18877 throw new Error("initializeWasm() must be awaited first!");
18879 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
18880 return nativeResponseValue;
18882 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18884 export function ChannelDetails_set_funding_txo(this_ptr: number, val: number): void {
18885 if(!isWasmInitialized) {
18886 throw new Error("initializeWasm() must be awaited first!");
18888 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
18889 // debug statements here
18891 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18893 export function ChannelDetails_get_channel_type(this_ptr: number): number {
18894 if(!isWasmInitialized) {
18895 throw new Error("initializeWasm() must be awaited first!");
18897 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
18898 return nativeResponseValue;
18900 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
18902 export function ChannelDetails_set_channel_type(this_ptr: number, val: number): void {
18903 if(!isWasmInitialized) {
18904 throw new Error("initializeWasm() must be awaited first!");
18906 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
18907 // debug statements here
18909 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18911 export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
18912 if(!isWasmInitialized) {
18913 throw new Error("initializeWasm() must be awaited first!");
18915 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
18916 return nativeResponseValue;
18918 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18920 export function ChannelDetails_set_short_channel_id(this_ptr: number, val: number): void {
18921 if(!isWasmInitialized) {
18922 throw new Error("initializeWasm() must be awaited first!");
18924 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
18925 // debug statements here
18927 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18929 export function ChannelDetails_get_outbound_scid_alias(this_ptr: number): number {
18930 if(!isWasmInitialized) {
18931 throw new Error("initializeWasm() must be awaited first!");
18933 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
18934 return nativeResponseValue;
18936 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18938 export function ChannelDetails_set_outbound_scid_alias(this_ptr: number, val: number): void {
18939 if(!isWasmInitialized) {
18940 throw new Error("initializeWasm() must be awaited first!");
18942 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
18943 // debug statements here
18945 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18947 export function ChannelDetails_get_inbound_scid_alias(this_ptr: number): number {
18948 if(!isWasmInitialized) {
18949 throw new Error("initializeWasm() must be awaited first!");
18951 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
18952 return nativeResponseValue;
18954 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18956 export function ChannelDetails_set_inbound_scid_alias(this_ptr: number, val: number): void {
18957 if(!isWasmInitialized) {
18958 throw new Error("initializeWasm() must be awaited first!");
18960 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
18961 // debug statements here
18963 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18965 export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): bigint {
18966 if(!isWasmInitialized) {
18967 throw new Error("initializeWasm() must be awaited first!");
18969 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
18970 return nativeResponseValue;
18972 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
18974 export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18975 if(!isWasmInitialized) {
18976 throw new Error("initializeWasm() must be awaited first!");
18978 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
18979 // debug statements here
18981 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
18983 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: number): number {
18984 if(!isWasmInitialized) {
18985 throw new Error("initializeWasm() must be awaited first!");
18987 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
18988 return nativeResponseValue;
18990 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18992 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: number, val: number): void {
18993 if(!isWasmInitialized) {
18994 throw new Error("initializeWasm() must be awaited first!");
18996 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
18997 // debug statements here
18999 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19001 export function ChannelDetails_get_user_channel_id(this_ptr: number): bigint {
19002 if(!isWasmInitialized) {
19003 throw new Error("initializeWasm() must be awaited first!");
19005 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
19006 return nativeResponseValue;
19008 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19010 export function ChannelDetails_set_user_channel_id(this_ptr: number, val: bigint): void {
19011 if(!isWasmInitialized) {
19012 throw new Error("initializeWasm() must be awaited first!");
19014 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
19015 // debug statements here
19017 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19019 export function ChannelDetails_get_balance_msat(this_ptr: number): bigint {
19020 if(!isWasmInitialized) {
19021 throw new Error("initializeWasm() must be awaited first!");
19023 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
19024 return nativeResponseValue;
19026 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19028 export function ChannelDetails_set_balance_msat(this_ptr: number, val: bigint): void {
19029 if(!isWasmInitialized) {
19030 throw new Error("initializeWasm() must be awaited first!");
19032 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
19033 // debug statements here
19035 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19037 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: number): bigint {
19038 if(!isWasmInitialized) {
19039 throw new Error("initializeWasm() must be awaited first!");
19041 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
19042 return nativeResponseValue;
19044 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19046 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: number, val: bigint): void {
19047 if(!isWasmInitialized) {
19048 throw new Error("initializeWasm() must be awaited first!");
19050 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
19051 // debug statements here
19053 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19055 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: number): bigint {
19056 if(!isWasmInitialized) {
19057 throw new Error("initializeWasm() must be awaited first!");
19059 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
19060 return nativeResponseValue;
19062 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19064 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: number, val: bigint): void {
19065 if(!isWasmInitialized) {
19066 throw new Error("initializeWasm() must be awaited first!");
19068 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
19069 // debug statements here
19071 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19073 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: number): bigint {
19074 if(!isWasmInitialized) {
19075 throw new Error("initializeWasm() must be awaited first!");
19077 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
19078 return nativeResponseValue;
19080 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19082 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: number, val: bigint): void {
19083 if(!isWasmInitialized) {
19084 throw new Error("initializeWasm() must be awaited first!");
19086 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
19087 // debug statements here
19089 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19091 export function ChannelDetails_get_confirmations_required(this_ptr: number): number {
19092 if(!isWasmInitialized) {
19093 throw new Error("initializeWasm() must be awaited first!");
19095 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
19096 return nativeResponseValue;
19098 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
19100 export function ChannelDetails_set_confirmations_required(this_ptr: number, val: number): void {
19101 if(!isWasmInitialized) {
19102 throw new Error("initializeWasm() must be awaited first!");
19104 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
19105 // debug statements here
19107 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19109 export function ChannelDetails_get_force_close_spend_delay(this_ptr: number): number {
19110 if(!isWasmInitialized) {
19111 throw new Error("initializeWasm() must be awaited first!");
19113 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
19114 return nativeResponseValue;
19116 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
19118 export function ChannelDetails_set_force_close_spend_delay(this_ptr: number, val: number): void {
19119 if(!isWasmInitialized) {
19120 throw new Error("initializeWasm() must be awaited first!");
19122 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
19123 // debug statements here
19125 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19127 export function ChannelDetails_get_is_outbound(this_ptr: number): boolean {
19128 if(!isWasmInitialized) {
19129 throw new Error("initializeWasm() must be awaited first!");
19131 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
19132 return nativeResponseValue;
19134 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19136 export function ChannelDetails_set_is_outbound(this_ptr: number, val: boolean): void {
19137 if(!isWasmInitialized) {
19138 throw new Error("initializeWasm() must be awaited first!");
19140 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
19141 // debug statements here
19143 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19145 export function ChannelDetails_get_is_channel_ready(this_ptr: number): boolean {
19146 if(!isWasmInitialized) {
19147 throw new Error("initializeWasm() must be awaited first!");
19149 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
19150 return nativeResponseValue;
19152 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19154 export function ChannelDetails_set_is_channel_ready(this_ptr: number, val: boolean): void {
19155 if(!isWasmInitialized) {
19156 throw new Error("initializeWasm() must be awaited first!");
19158 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
19159 // debug statements here
19161 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19163 export function ChannelDetails_get_is_usable(this_ptr: number): boolean {
19164 if(!isWasmInitialized) {
19165 throw new Error("initializeWasm() must be awaited first!");
19167 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
19168 return nativeResponseValue;
19170 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19172 export function ChannelDetails_set_is_usable(this_ptr: number, val: boolean): void {
19173 if(!isWasmInitialized) {
19174 throw new Error("initializeWasm() must be awaited first!");
19176 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
19177 // debug statements here
19179 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19181 export function ChannelDetails_get_is_public(this_ptr: number): boolean {
19182 if(!isWasmInitialized) {
19183 throw new Error("initializeWasm() must be awaited first!");
19185 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
19186 return nativeResponseValue;
19188 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19190 export function ChannelDetails_set_is_public(this_ptr: number, val: boolean): void {
19191 if(!isWasmInitialized) {
19192 throw new Error("initializeWasm() must be awaited first!");
19194 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
19195 // debug statements here
19197 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19199 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: number): number {
19200 if(!isWasmInitialized) {
19201 throw new Error("initializeWasm() must be awaited first!");
19203 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
19204 return nativeResponseValue;
19206 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19208 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: number, val: number): void {
19209 if(!isWasmInitialized) {
19210 throw new Error("initializeWasm() must be awaited first!");
19212 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
19213 // debug statements here
19215 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19217 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: number): number {
19218 if(!isWasmInitialized) {
19219 throw new Error("initializeWasm() must be awaited first!");
19221 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
19222 return nativeResponseValue;
19224 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19226 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: number, val: number): void {
19227 if(!isWasmInitialized) {
19228 throw new Error("initializeWasm() must be awaited first!");
19230 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
19231 // debug statements here
19233 // 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);
19235 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): number {
19236 if(!isWasmInitialized) {
19237 throw new Error("initializeWasm() must be awaited first!");
19239 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);
19240 return nativeResponseValue;
19242 // uintptr_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
19244 export function ChannelDetails_clone_ptr(arg: number): number {
19245 if(!isWasmInitialized) {
19246 throw new Error("initializeWasm() must be awaited first!");
19248 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
19249 return nativeResponseValue;
19251 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
19253 export function ChannelDetails_clone(orig: number): number {
19254 if(!isWasmInitialized) {
19255 throw new Error("initializeWasm() must be awaited first!");
19257 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
19258 return nativeResponseValue;
19260 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
19262 export function ChannelDetails_get_inbound_payment_scid(this_arg: number): number {
19263 if(!isWasmInitialized) {
19264 throw new Error("initializeWasm() must be awaited first!");
19266 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
19267 return nativeResponseValue;
19269 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
19271 export function ChannelDetails_get_outbound_payment_scid(this_arg: number): number {
19272 if(!isWasmInitialized) {
19273 throw new Error("initializeWasm() must be awaited first!");
19275 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
19276 return nativeResponseValue;
19278 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
19280 export function PaymentSendFailure_free(this_ptr: number): void {
19281 if(!isWasmInitialized) {
19282 throw new Error("initializeWasm() must be awaited first!");
19284 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
19285 // debug statements here
19287 // uintptr_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
19289 export function PaymentSendFailure_clone_ptr(arg: number): number {
19290 if(!isWasmInitialized) {
19291 throw new Error("initializeWasm() must be awaited first!");
19293 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
19294 return nativeResponseValue;
19296 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
19298 export function PaymentSendFailure_clone(orig: number): number {
19299 if(!isWasmInitialized) {
19300 throw new Error("initializeWasm() must be awaited first!");
19302 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
19303 return nativeResponseValue;
19305 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
19307 export function PaymentSendFailure_parameter_error(a: number): number {
19308 if(!isWasmInitialized) {
19309 throw new Error("initializeWasm() must be awaited first!");
19311 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
19312 return nativeResponseValue;
19314 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
19316 export function PaymentSendFailure_path_parameter_error(a: number): number {
19317 if(!isWasmInitialized) {
19318 throw new Error("initializeWasm() must be awaited first!");
19320 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
19321 return nativeResponseValue;
19323 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
19325 export function PaymentSendFailure_all_failed_retry_safe(a: number): number {
19326 if(!isWasmInitialized) {
19327 throw new Error("initializeWasm() must be awaited first!");
19329 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
19330 return nativeResponseValue;
19332 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
19334 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: number, payment_id: number): number {
19335 if(!isWasmInitialized) {
19336 throw new Error("initializeWasm() must be awaited first!");
19338 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
19339 return nativeResponseValue;
19341 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
19343 export function PhantomRouteHints_free(this_obj: number): void {
19344 if(!isWasmInitialized) {
19345 throw new Error("initializeWasm() must be awaited first!");
19347 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
19348 // debug statements here
19350 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
19352 export function PhantomRouteHints_get_channels(this_ptr: number): number {
19353 if(!isWasmInitialized) {
19354 throw new Error("initializeWasm() must be awaited first!");
19356 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
19357 return nativeResponseValue;
19359 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
19361 export function PhantomRouteHints_set_channels(this_ptr: number, val: number): void {
19362 if(!isWasmInitialized) {
19363 throw new Error("initializeWasm() must be awaited first!");
19365 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
19366 // debug statements here
19368 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
19370 export function PhantomRouteHints_get_phantom_scid(this_ptr: number): bigint {
19371 if(!isWasmInitialized) {
19372 throw new Error("initializeWasm() must be awaited first!");
19374 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
19375 return nativeResponseValue;
19377 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
19379 export function PhantomRouteHints_set_phantom_scid(this_ptr: number, val: bigint): void {
19380 if(!isWasmInitialized) {
19381 throw new Error("initializeWasm() must be awaited first!");
19383 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
19384 // debug statements here
19386 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
19388 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: number): number {
19389 if(!isWasmInitialized) {
19390 throw new Error("initializeWasm() must be awaited first!");
19392 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
19393 return nativeResponseValue;
19395 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19397 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: number, val: number): void {
19398 if(!isWasmInitialized) {
19399 throw new Error("initializeWasm() must be awaited first!");
19401 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
19402 // debug statements here
19404 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
19406 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): number {
19407 if(!isWasmInitialized) {
19408 throw new Error("initializeWasm() must be awaited first!");
19410 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
19411 return nativeResponseValue;
19413 // uintptr_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
19415 export function PhantomRouteHints_clone_ptr(arg: number): number {
19416 if(!isWasmInitialized) {
19417 throw new Error("initializeWasm() must be awaited first!");
19419 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
19420 return nativeResponseValue;
19422 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
19424 export function PhantomRouteHints_clone(orig: number): number {
19425 if(!isWasmInitialized) {
19426 throw new Error("initializeWasm() must be awaited first!");
19428 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
19429 return nativeResponseValue;
19431 // 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);
19433 export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
19434 if(!isWasmInitialized) {
19435 throw new Error("initializeWasm() must be awaited first!");
19437 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
19438 return nativeResponseValue;
19440 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
19442 export function ChannelManager_get_current_default_configuration(this_arg: number): number {
19443 if(!isWasmInitialized) {
19444 throw new Error("initializeWasm() must be awaited first!");
19446 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
19447 return nativeResponseValue;
19449 // 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);
19451 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 {
19452 if(!isWasmInitialized) {
19453 throw new Error("initializeWasm() must be awaited first!");
19455 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
19456 return nativeResponseValue;
19458 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
19460 export function ChannelManager_list_channels(this_arg: number): number {
19461 if(!isWasmInitialized) {
19462 throw new Error("initializeWasm() must be awaited first!");
19464 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
19465 return nativeResponseValue;
19467 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
19469 export function ChannelManager_list_usable_channels(this_arg: number): number {
19470 if(!isWasmInitialized) {
19471 throw new Error("initializeWasm() must be awaited first!");
19473 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
19474 return nativeResponseValue;
19476 // 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);
19478 export function ChannelManager_close_channel(this_arg: number, channel_id: number, counterparty_node_id: number): number {
19479 if(!isWasmInitialized) {
19480 throw new Error("initializeWasm() must be awaited first!");
19482 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
19483 return nativeResponseValue;
19485 // 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);
19487 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 {
19488 if(!isWasmInitialized) {
19489 throw new Error("initializeWasm() must be awaited first!");
19491 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight);
19492 return nativeResponseValue;
19494 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
19496 export function ChannelManager_force_close_channel(this_arg: number, channel_id: number, counterparty_node_id: number): number {
19497 if(!isWasmInitialized) {
19498 throw new Error("initializeWasm() must be awaited first!");
19500 const nativeResponseValue = wasm.TS_ChannelManager_force_close_channel(this_arg, channel_id, counterparty_node_id);
19501 return nativeResponseValue;
19503 // void ChannelManager_force_close_all_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
19505 export function ChannelManager_force_close_all_channels(this_arg: number): void {
19506 if(!isWasmInitialized) {
19507 throw new Error("initializeWasm() must be awaited first!");
19509 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels(this_arg);
19510 // debug statements here
19512 // 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);
19514 export function ChannelManager_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
19515 if(!isWasmInitialized) {
19516 throw new Error("initializeWasm() must be awaited first!");
19518 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
19519 return nativeResponseValue;
19521 // 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);
19523 export function ChannelManager_retry_payment(this_arg: number, route: number, payment_id: number): number {
19524 if(!isWasmInitialized) {
19525 throw new Error("initializeWasm() must be awaited first!");
19527 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
19528 return nativeResponseValue;
19530 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
19532 export function ChannelManager_abandon_payment(this_arg: number, payment_id: number): void {
19533 if(!isWasmInitialized) {
19534 throw new Error("initializeWasm() must be awaited first!");
19536 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
19537 // debug statements here
19539 // 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);
19541 export function ChannelManager_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
19542 if(!isWasmInitialized) {
19543 throw new Error("initializeWasm() must be awaited first!");
19545 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
19546 return nativeResponseValue;
19548 // 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);
19550 export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): number {
19551 if(!isWasmInitialized) {
19552 throw new Error("initializeWasm() must be awaited first!");
19554 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
19555 return nativeResponseValue;
19557 // void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
19559 export function ChannelManager_broadcast_node_announcement(this_arg: number, rgb: number, alias: number, addresses: number): void {
19560 if(!isWasmInitialized) {
19561 throw new Error("initializeWasm() must be awaited first!");
19563 const nativeResponseValue = wasm.TS_ChannelManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
19564 // debug statements here
19566 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
19568 export function ChannelManager_process_pending_htlc_forwards(this_arg: number): void {
19569 if(!isWasmInitialized) {
19570 throw new Error("initializeWasm() must be awaited first!");
19572 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
19573 // debug statements here
19575 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
19577 export function ChannelManager_timer_tick_occurred(this_arg: number): void {
19578 if(!isWasmInitialized) {
19579 throw new Error("initializeWasm() must be awaited first!");
19581 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
19582 // debug statements here
19584 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
19586 export function ChannelManager_fail_htlc_backwards(this_arg: number, payment_hash: number): void {
19587 if(!isWasmInitialized) {
19588 throw new Error("initializeWasm() must be awaited first!");
19590 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
19591 // debug statements here
19593 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
19595 export function ChannelManager_claim_funds(this_arg: number, payment_preimage: number): void {
19596 if(!isWasmInitialized) {
19597 throw new Error("initializeWasm() must be awaited first!");
19599 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
19600 // debug statements here
19602 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
19604 export function ChannelManager_get_our_node_id(this_arg: number): number {
19605 if(!isWasmInitialized) {
19606 throw new Error("initializeWasm() must be awaited first!");
19608 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
19609 return nativeResponseValue;
19611 // 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);
19613 export function ChannelManager_accept_inbound_channel(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): number {
19614 if(!isWasmInitialized) {
19615 throw new Error("initializeWasm() must be awaited first!");
19617 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
19618 return nativeResponseValue;
19620 // 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);
19622 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 {
19623 if(!isWasmInitialized) {
19624 throw new Error("initializeWasm() must be awaited first!");
19626 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
19627 return nativeResponseValue;
19629 // 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);
19631 export function ChannelManager_create_inbound_payment(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19632 if(!isWasmInitialized) {
19633 throw new Error("initializeWasm() must be awaited first!");
19635 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
19636 return nativeResponseValue;
19638 // 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);
19640 export function ChannelManager_create_inbound_payment_legacy(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19641 if(!isWasmInitialized) {
19642 throw new Error("initializeWasm() must be awaited first!");
19644 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
19645 return nativeResponseValue;
19647 // 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);
19649 export function ChannelManager_create_inbound_payment_for_hash(this_arg: number, payment_hash: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19650 if(!isWasmInitialized) {
19651 throw new Error("initializeWasm() must be awaited first!");
19653 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
19654 return nativeResponseValue;
19656 // 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);
19658 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 {
19659 if(!isWasmInitialized) {
19660 throw new Error("initializeWasm() must be awaited first!");
19662 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
19663 return nativeResponseValue;
19665 // 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);
19667 export function ChannelManager_get_payment_preimage(this_arg: number, payment_hash: number, payment_secret: number): number {
19668 if(!isWasmInitialized) {
19669 throw new Error("initializeWasm() must be awaited first!");
19671 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
19672 return nativeResponseValue;
19674 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
19676 export function ChannelManager_get_phantom_scid(this_arg: number): bigint {
19677 if(!isWasmInitialized) {
19678 throw new Error("initializeWasm() must be awaited first!");
19680 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
19681 return nativeResponseValue;
19683 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
19685 export function ChannelManager_get_phantom_route_hints(this_arg: number): number {
19686 if(!isWasmInitialized) {
19687 throw new Error("initializeWasm() must be awaited first!");
19689 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
19690 return nativeResponseValue;
19692 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
19694 export function ChannelManager_as_MessageSendEventsProvider(this_arg: number): number {
19695 if(!isWasmInitialized) {
19696 throw new Error("initializeWasm() must be awaited first!");
19698 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
19699 return nativeResponseValue;
19701 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
19703 export function ChannelManager_as_EventsProvider(this_arg: number): number {
19704 if(!isWasmInitialized) {
19705 throw new Error("initializeWasm() must be awaited first!");
19707 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
19708 return nativeResponseValue;
19710 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
19712 export function ChannelManager_as_Listen(this_arg: number): number {
19713 if(!isWasmInitialized) {
19714 throw new Error("initializeWasm() must be awaited first!");
19716 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
19717 return nativeResponseValue;
19719 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
19721 export function ChannelManager_as_Confirm(this_arg: number): number {
19722 if(!isWasmInitialized) {
19723 throw new Error("initializeWasm() must be awaited first!");
19725 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
19726 return nativeResponseValue;
19728 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
19730 export function ChannelManager_await_persistable_update(this_arg: number): void {
19731 if(!isWasmInitialized) {
19732 throw new Error("initializeWasm() must be awaited first!");
19734 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
19735 // debug statements here
19737 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
19739 export function ChannelManager_current_best_block(this_arg: number): number {
19740 if(!isWasmInitialized) {
19741 throw new Error("initializeWasm() must be awaited first!");
19743 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
19744 return nativeResponseValue;
19746 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
19748 export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number {
19749 if(!isWasmInitialized) {
19750 throw new Error("initializeWasm() must be awaited first!");
19752 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
19753 return nativeResponseValue;
19755 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
19757 export function CounterpartyForwardingInfo_write(obj: number): number {
19758 if(!isWasmInitialized) {
19759 throw new Error("initializeWasm() must be awaited first!");
19761 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
19762 return nativeResponseValue;
19764 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
19766 export function CounterpartyForwardingInfo_read(ser: number): number {
19767 if(!isWasmInitialized) {
19768 throw new Error("initializeWasm() must be awaited first!");
19770 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
19771 return nativeResponseValue;
19773 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
19775 export function ChannelCounterparty_write(obj: number): number {
19776 if(!isWasmInitialized) {
19777 throw new Error("initializeWasm() must be awaited first!");
19779 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
19780 return nativeResponseValue;
19782 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
19784 export function ChannelCounterparty_read(ser: number): number {
19785 if(!isWasmInitialized) {
19786 throw new Error("initializeWasm() must be awaited first!");
19788 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
19789 return nativeResponseValue;
19791 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
19793 export function ChannelDetails_write(obj: number): number {
19794 if(!isWasmInitialized) {
19795 throw new Error("initializeWasm() must be awaited first!");
19797 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
19798 return nativeResponseValue;
19800 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
19802 export function ChannelDetails_read(ser: number): number {
19803 if(!isWasmInitialized) {
19804 throw new Error("initializeWasm() must be awaited first!");
19806 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
19807 return nativeResponseValue;
19809 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
19811 export function PhantomRouteHints_write(obj: number): number {
19812 if(!isWasmInitialized) {
19813 throw new Error("initializeWasm() must be awaited first!");
19815 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
19816 return nativeResponseValue;
19818 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
19820 export function PhantomRouteHints_read(ser: number): number {
19821 if(!isWasmInitialized) {
19822 throw new Error("initializeWasm() must be awaited first!");
19824 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
19825 return nativeResponseValue;
19827 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
19829 export function ChannelManager_write(obj: number): number {
19830 if(!isWasmInitialized) {
19831 throw new Error("initializeWasm() must be awaited first!");
19833 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
19834 return nativeResponseValue;
19836 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
19838 export function ChannelManagerReadArgs_free(this_obj: number): void {
19839 if(!isWasmInitialized) {
19840 throw new Error("initializeWasm() must be awaited first!");
19842 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
19843 // debug statements here
19845 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19847 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: number): number {
19848 if(!isWasmInitialized) {
19849 throw new Error("initializeWasm() must be awaited first!");
19851 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
19852 return nativeResponseValue;
19854 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
19856 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: number, val: number): void {
19857 if(!isWasmInitialized) {
19858 throw new Error("initializeWasm() must be awaited first!");
19860 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
19861 // debug statements here
19863 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19865 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: number): number {
19866 if(!isWasmInitialized) {
19867 throw new Error("initializeWasm() must be awaited first!");
19869 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
19870 return nativeResponseValue;
19872 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
19874 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: number, val: number): void {
19875 if(!isWasmInitialized) {
19876 throw new Error("initializeWasm() must be awaited first!");
19878 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
19879 // debug statements here
19881 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19883 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: number): number {
19884 if(!isWasmInitialized) {
19885 throw new Error("initializeWasm() must be awaited first!");
19887 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
19888 return nativeResponseValue;
19890 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
19892 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: number, val: number): void {
19893 if(!isWasmInitialized) {
19894 throw new Error("initializeWasm() must be awaited first!");
19896 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
19897 // debug statements here
19899 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19901 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: number): number {
19902 if(!isWasmInitialized) {
19903 throw new Error("initializeWasm() must be awaited first!");
19905 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
19906 return nativeResponseValue;
19908 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
19910 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: number, val: number): void {
19911 if(!isWasmInitialized) {
19912 throw new Error("initializeWasm() must be awaited first!");
19914 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
19915 // debug statements here
19917 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19919 export function ChannelManagerReadArgs_get_logger(this_ptr: number): number {
19920 if(!isWasmInitialized) {
19921 throw new Error("initializeWasm() must be awaited first!");
19923 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
19924 return nativeResponseValue;
19926 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
19928 export function ChannelManagerReadArgs_set_logger(this_ptr: number, val: number): void {
19929 if(!isWasmInitialized) {
19930 throw new Error("initializeWasm() must be awaited first!");
19932 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
19933 // debug statements here
19935 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
19937 export function ChannelManagerReadArgs_get_default_config(this_ptr: number): number {
19938 if(!isWasmInitialized) {
19939 throw new Error("initializeWasm() must be awaited first!");
19941 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
19942 return nativeResponseValue;
19944 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
19946 export function ChannelManagerReadArgs_set_default_config(this_ptr: number, val: number): void {
19947 if(!isWasmInitialized) {
19948 throw new Error("initializeWasm() must be awaited first!");
19950 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
19951 // debug statements here
19953 // 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);
19955 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 {
19956 if(!isWasmInitialized) {
19957 throw new Error("initializeWasm() must be awaited first!");
19959 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
19960 return nativeResponseValue;
19962 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
19964 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: number): number {
19965 if(!isWasmInitialized) {
19966 throw new Error("initializeWasm() must be awaited first!");
19968 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
19969 return nativeResponseValue;
19971 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
19973 export function ExpandedKey_free(this_obj: number): void {
19974 if(!isWasmInitialized) {
19975 throw new Error("initializeWasm() must be awaited first!");
19977 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
19978 // debug statements here
19980 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
19982 export function ExpandedKey_new(key_material: number): number {
19983 if(!isWasmInitialized) {
19984 throw new Error("initializeWasm() must be awaited first!");
19986 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
19987 return nativeResponseValue;
19989 // 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);
19991 export function create(keys: number, min_value_msat: number, invoice_expiry_delta_secs: number, keys_manager: number, current_time: bigint): number {
19992 if(!isWasmInitialized) {
19993 throw new Error("initializeWasm() must be awaited first!");
19995 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, keys_manager, current_time);
19996 return nativeResponseValue;
19998 // 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);
20000 export function create_from_hash(keys: number, min_value_msat: number, payment_hash: number, invoice_expiry_delta_secs: number, current_time: bigint): number {
20001 if(!isWasmInitialized) {
20002 throw new Error("initializeWasm() must be awaited first!");
20004 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time);
20005 return nativeResponseValue;
20007 // void DecodeError_free(struct LDKDecodeError this_obj);
20009 export function DecodeError_free(this_obj: number): void {
20010 if(!isWasmInitialized) {
20011 throw new Error("initializeWasm() must be awaited first!");
20013 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
20014 // debug statements here
20016 // uintptr_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
20018 export function DecodeError_clone_ptr(arg: number): number {
20019 if(!isWasmInitialized) {
20020 throw new Error("initializeWasm() must be awaited first!");
20022 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
20023 return nativeResponseValue;
20025 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
20027 export function DecodeError_clone(orig: number): number {
20028 if(!isWasmInitialized) {
20029 throw new Error("initializeWasm() must be awaited first!");
20031 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
20032 return nativeResponseValue;
20034 // void Init_free(struct LDKInit this_obj);
20036 export function Init_free(this_obj: number): void {
20037 if(!isWasmInitialized) {
20038 throw new Error("initializeWasm() must be awaited first!");
20040 const nativeResponseValue = wasm.TS_Init_free(this_obj);
20041 // debug statements here
20043 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
20045 export function Init_get_features(this_ptr: number): number {
20046 if(!isWasmInitialized) {
20047 throw new Error("initializeWasm() must be awaited first!");
20049 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
20050 return nativeResponseValue;
20052 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
20054 export function Init_set_features(this_ptr: number, val: number): void {
20055 if(!isWasmInitialized) {
20056 throw new Error("initializeWasm() must be awaited first!");
20058 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
20059 // debug statements here
20061 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
20063 export function Init_get_remote_network_address(this_ptr: number): number {
20064 if(!isWasmInitialized) {
20065 throw new Error("initializeWasm() must be awaited first!");
20067 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
20068 return nativeResponseValue;
20070 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
20072 export function Init_set_remote_network_address(this_ptr: number, val: number): void {
20073 if(!isWasmInitialized) {
20074 throw new Error("initializeWasm() must be awaited first!");
20076 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
20077 // debug statements here
20079 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
20081 export function Init_new(features_arg: number, remote_network_address_arg: number): number {
20082 if(!isWasmInitialized) {
20083 throw new Error("initializeWasm() must be awaited first!");
20085 const nativeResponseValue = wasm.TS_Init_new(features_arg, remote_network_address_arg);
20086 return nativeResponseValue;
20088 // uintptr_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
20090 export function Init_clone_ptr(arg: number): number {
20091 if(!isWasmInitialized) {
20092 throw new Error("initializeWasm() must be awaited first!");
20094 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
20095 return nativeResponseValue;
20097 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
20099 export function Init_clone(orig: number): number {
20100 if(!isWasmInitialized) {
20101 throw new Error("initializeWasm() must be awaited first!");
20103 const nativeResponseValue = wasm.TS_Init_clone(orig);
20104 return nativeResponseValue;
20106 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
20108 export function ErrorMessage_free(this_obj: number): void {
20109 if(!isWasmInitialized) {
20110 throw new Error("initializeWasm() must be awaited first!");
20112 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
20113 // debug statements here
20115 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
20117 export function ErrorMessage_get_channel_id(this_ptr: number): number {
20118 if(!isWasmInitialized) {
20119 throw new Error("initializeWasm() must be awaited first!");
20121 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
20122 return nativeResponseValue;
20124 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20126 export function ErrorMessage_set_channel_id(this_ptr: number, val: number): void {
20127 if(!isWasmInitialized) {
20128 throw new Error("initializeWasm() must be awaited first!");
20130 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
20131 // debug statements here
20133 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
20135 export function ErrorMessage_get_data(this_ptr: number): number {
20136 if(!isWasmInitialized) {
20137 throw new Error("initializeWasm() must be awaited first!");
20139 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
20140 return nativeResponseValue;
20142 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20144 export function ErrorMessage_set_data(this_ptr: number, val: number): void {
20145 if(!isWasmInitialized) {
20146 throw new Error("initializeWasm() must be awaited first!");
20148 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
20149 // debug statements here
20151 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
20153 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): number {
20154 if(!isWasmInitialized) {
20155 throw new Error("initializeWasm() must be awaited first!");
20157 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
20158 return nativeResponseValue;
20160 // uintptr_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
20162 export function ErrorMessage_clone_ptr(arg: number): number {
20163 if(!isWasmInitialized) {
20164 throw new Error("initializeWasm() must be awaited first!");
20166 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
20167 return nativeResponseValue;
20169 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
20171 export function ErrorMessage_clone(orig: number): number {
20172 if(!isWasmInitialized) {
20173 throw new Error("initializeWasm() must be awaited first!");
20175 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
20176 return nativeResponseValue;
20178 // void WarningMessage_free(struct LDKWarningMessage this_obj);
20180 export function WarningMessage_free(this_obj: number): void {
20181 if(!isWasmInitialized) {
20182 throw new Error("initializeWasm() must be awaited first!");
20184 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
20185 // debug statements here
20187 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
20189 export function WarningMessage_get_channel_id(this_ptr: number): number {
20190 if(!isWasmInitialized) {
20191 throw new Error("initializeWasm() must be awaited first!");
20193 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
20194 return nativeResponseValue;
20196 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20198 export function WarningMessage_set_channel_id(this_ptr: number, val: number): void {
20199 if(!isWasmInitialized) {
20200 throw new Error("initializeWasm() must be awaited first!");
20202 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
20203 // debug statements here
20205 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
20207 export function WarningMessage_get_data(this_ptr: number): number {
20208 if(!isWasmInitialized) {
20209 throw new Error("initializeWasm() must be awaited first!");
20211 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
20212 return nativeResponseValue;
20214 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20216 export function WarningMessage_set_data(this_ptr: number, val: number): void {
20217 if(!isWasmInitialized) {
20218 throw new Error("initializeWasm() must be awaited first!");
20220 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
20221 // debug statements here
20223 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
20225 export function WarningMessage_new(channel_id_arg: number, data_arg: number): number {
20226 if(!isWasmInitialized) {
20227 throw new Error("initializeWasm() must be awaited first!");
20229 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
20230 return nativeResponseValue;
20232 // uintptr_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
20234 export function WarningMessage_clone_ptr(arg: number): number {
20235 if(!isWasmInitialized) {
20236 throw new Error("initializeWasm() must be awaited first!");
20238 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
20239 return nativeResponseValue;
20241 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
20243 export function WarningMessage_clone(orig: number): number {
20244 if(!isWasmInitialized) {
20245 throw new Error("initializeWasm() must be awaited first!");
20247 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
20248 return nativeResponseValue;
20250 // void Ping_free(struct LDKPing this_obj);
20252 export function Ping_free(this_obj: number): void {
20253 if(!isWasmInitialized) {
20254 throw new Error("initializeWasm() must be awaited first!");
20256 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
20257 // debug statements here
20259 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
20261 export function Ping_get_ponglen(this_ptr: number): number {
20262 if(!isWasmInitialized) {
20263 throw new Error("initializeWasm() must be awaited first!");
20265 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
20266 return nativeResponseValue;
20268 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
20270 export function Ping_set_ponglen(this_ptr: number, val: number): void {
20271 if(!isWasmInitialized) {
20272 throw new Error("initializeWasm() must be awaited first!");
20274 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
20275 // debug statements here
20277 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
20279 export function Ping_get_byteslen(this_ptr: number): number {
20280 if(!isWasmInitialized) {
20281 throw new Error("initializeWasm() must be awaited first!");
20283 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
20284 return nativeResponseValue;
20286 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
20288 export function Ping_set_byteslen(this_ptr: number, val: number): void {
20289 if(!isWasmInitialized) {
20290 throw new Error("initializeWasm() must be awaited first!");
20292 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
20293 // debug statements here
20295 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
20297 export function Ping_new(ponglen_arg: number, byteslen_arg: number): number {
20298 if(!isWasmInitialized) {
20299 throw new Error("initializeWasm() must be awaited first!");
20301 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
20302 return nativeResponseValue;
20304 // uintptr_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
20306 export function Ping_clone_ptr(arg: number): number {
20307 if(!isWasmInitialized) {
20308 throw new Error("initializeWasm() must be awaited first!");
20310 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
20311 return nativeResponseValue;
20313 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
20315 export function Ping_clone(orig: number): number {
20316 if(!isWasmInitialized) {
20317 throw new Error("initializeWasm() must be awaited first!");
20319 const nativeResponseValue = wasm.TS_Ping_clone(orig);
20320 return nativeResponseValue;
20322 // void Pong_free(struct LDKPong this_obj);
20324 export function Pong_free(this_obj: number): void {
20325 if(!isWasmInitialized) {
20326 throw new Error("initializeWasm() must be awaited first!");
20328 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
20329 // debug statements here
20331 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
20333 export function Pong_get_byteslen(this_ptr: number): number {
20334 if(!isWasmInitialized) {
20335 throw new Error("initializeWasm() must be awaited first!");
20337 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
20338 return nativeResponseValue;
20340 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
20342 export function Pong_set_byteslen(this_ptr: number, val: number): void {
20343 if(!isWasmInitialized) {
20344 throw new Error("initializeWasm() must be awaited first!");
20346 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
20347 // debug statements here
20349 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
20351 export function Pong_new(byteslen_arg: number): number {
20352 if(!isWasmInitialized) {
20353 throw new Error("initializeWasm() must be awaited first!");
20355 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
20356 return nativeResponseValue;
20358 // uintptr_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
20360 export function Pong_clone_ptr(arg: number): number {
20361 if(!isWasmInitialized) {
20362 throw new Error("initializeWasm() must be awaited first!");
20364 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
20365 return nativeResponseValue;
20367 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
20369 export function Pong_clone(orig: number): number {
20370 if(!isWasmInitialized) {
20371 throw new Error("initializeWasm() must be awaited first!");
20373 const nativeResponseValue = wasm.TS_Pong_clone(orig);
20374 return nativeResponseValue;
20376 // void OpenChannel_free(struct LDKOpenChannel this_obj);
20378 export function OpenChannel_free(this_obj: number): void {
20379 if(!isWasmInitialized) {
20380 throw new Error("initializeWasm() must be awaited first!");
20382 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
20383 // debug statements here
20385 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
20387 export function OpenChannel_get_chain_hash(this_ptr: number): number {
20388 if(!isWasmInitialized) {
20389 throw new Error("initializeWasm() must be awaited first!");
20391 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
20392 return nativeResponseValue;
20394 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20396 export function OpenChannel_set_chain_hash(this_ptr: number, val: number): void {
20397 if(!isWasmInitialized) {
20398 throw new Error("initializeWasm() must be awaited first!");
20400 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
20401 // debug statements here
20403 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
20405 export function OpenChannel_get_temporary_channel_id(this_ptr: number): number {
20406 if(!isWasmInitialized) {
20407 throw new Error("initializeWasm() must be awaited first!");
20409 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
20410 return nativeResponseValue;
20412 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20414 export function OpenChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
20415 if(!isWasmInitialized) {
20416 throw new Error("initializeWasm() must be awaited first!");
20418 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
20419 // debug statements here
20421 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20423 export function OpenChannel_get_funding_satoshis(this_ptr: number): bigint {
20424 if(!isWasmInitialized) {
20425 throw new Error("initializeWasm() must be awaited first!");
20427 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
20428 return nativeResponseValue;
20430 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20432 export function OpenChannel_set_funding_satoshis(this_ptr: number, val: bigint): void {
20433 if(!isWasmInitialized) {
20434 throw new Error("initializeWasm() must be awaited first!");
20436 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
20437 // debug statements here
20439 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20441 export function OpenChannel_get_push_msat(this_ptr: number): bigint {
20442 if(!isWasmInitialized) {
20443 throw new Error("initializeWasm() must be awaited first!");
20445 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
20446 return nativeResponseValue;
20448 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20450 export function OpenChannel_set_push_msat(this_ptr: number, val: bigint): void {
20451 if(!isWasmInitialized) {
20452 throw new Error("initializeWasm() must be awaited first!");
20454 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
20455 // debug statements here
20457 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20459 export function OpenChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
20460 if(!isWasmInitialized) {
20461 throw new Error("initializeWasm() must be awaited first!");
20463 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
20464 return nativeResponseValue;
20466 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20468 export function OpenChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
20469 if(!isWasmInitialized) {
20470 throw new Error("initializeWasm() must be awaited first!");
20472 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
20473 // debug statements here
20475 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20477 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
20478 if(!isWasmInitialized) {
20479 throw new Error("initializeWasm() must be awaited first!");
20481 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
20482 return nativeResponseValue;
20484 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20486 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
20487 if(!isWasmInitialized) {
20488 throw new Error("initializeWasm() must be awaited first!");
20490 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
20491 // debug statements here
20493 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20495 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
20496 if(!isWasmInitialized) {
20497 throw new Error("initializeWasm() must be awaited first!");
20499 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
20500 return nativeResponseValue;
20502 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20504 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
20505 if(!isWasmInitialized) {
20506 throw new Error("initializeWasm() must be awaited first!");
20508 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
20509 // debug statements here
20511 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20513 export function OpenChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
20514 if(!isWasmInitialized) {
20515 throw new Error("initializeWasm() must be awaited first!");
20517 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
20518 return nativeResponseValue;
20520 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20522 export function OpenChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
20523 if(!isWasmInitialized) {
20524 throw new Error("initializeWasm() must be awaited first!");
20526 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
20527 // debug statements here
20529 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20531 export function OpenChannel_get_feerate_per_kw(this_ptr: number): number {
20532 if(!isWasmInitialized) {
20533 throw new Error("initializeWasm() must be awaited first!");
20535 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
20536 return nativeResponseValue;
20538 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
20540 export function OpenChannel_set_feerate_per_kw(this_ptr: number, val: number): void {
20541 if(!isWasmInitialized) {
20542 throw new Error("initializeWasm() must be awaited first!");
20544 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
20545 // debug statements here
20547 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20549 export function OpenChannel_get_to_self_delay(this_ptr: number): number {
20550 if(!isWasmInitialized) {
20551 throw new Error("initializeWasm() must be awaited first!");
20553 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
20554 return nativeResponseValue;
20556 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
20558 export function OpenChannel_set_to_self_delay(this_ptr: number, val: number): void {
20559 if(!isWasmInitialized) {
20560 throw new Error("initializeWasm() must be awaited first!");
20562 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
20563 // debug statements here
20565 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20567 export function OpenChannel_get_max_accepted_htlcs(this_ptr: number): number {
20568 if(!isWasmInitialized) {
20569 throw new Error("initializeWasm() must be awaited first!");
20571 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
20572 return nativeResponseValue;
20574 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
20576 export function OpenChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
20577 if(!isWasmInitialized) {
20578 throw new Error("initializeWasm() must be awaited first!");
20580 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
20581 // debug statements here
20583 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20585 export function OpenChannel_get_funding_pubkey(this_ptr: number): number {
20586 if(!isWasmInitialized) {
20587 throw new Error("initializeWasm() must be awaited first!");
20589 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
20590 return nativeResponseValue;
20592 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20594 export function OpenChannel_set_funding_pubkey(this_ptr: number, val: number): void {
20595 if(!isWasmInitialized) {
20596 throw new Error("initializeWasm() must be awaited first!");
20598 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
20599 // debug statements here
20601 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20603 export function OpenChannel_get_revocation_basepoint(this_ptr: number): number {
20604 if(!isWasmInitialized) {
20605 throw new Error("initializeWasm() must be awaited first!");
20607 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
20608 return nativeResponseValue;
20610 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20612 export function OpenChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
20613 if(!isWasmInitialized) {
20614 throw new Error("initializeWasm() must be awaited first!");
20616 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
20617 // debug statements here
20619 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20621 export function OpenChannel_get_payment_point(this_ptr: number): number {
20622 if(!isWasmInitialized) {
20623 throw new Error("initializeWasm() must be awaited first!");
20625 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
20626 return nativeResponseValue;
20628 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20630 export function OpenChannel_set_payment_point(this_ptr: number, val: number): void {
20631 if(!isWasmInitialized) {
20632 throw new Error("initializeWasm() must be awaited first!");
20634 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
20635 // debug statements here
20637 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20639 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: number): number {
20640 if(!isWasmInitialized) {
20641 throw new Error("initializeWasm() must be awaited first!");
20643 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
20644 return nativeResponseValue;
20646 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20648 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
20649 if(!isWasmInitialized) {
20650 throw new Error("initializeWasm() must be awaited first!");
20652 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
20653 // debug statements here
20655 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20657 export function OpenChannel_get_htlc_basepoint(this_ptr: number): number {
20658 if(!isWasmInitialized) {
20659 throw new Error("initializeWasm() must be awaited first!");
20661 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
20662 return nativeResponseValue;
20664 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20666 export function OpenChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
20667 if(!isWasmInitialized) {
20668 throw new Error("initializeWasm() must be awaited first!");
20670 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
20671 // debug statements here
20673 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20675 export function OpenChannel_get_first_per_commitment_point(this_ptr: number): number {
20676 if(!isWasmInitialized) {
20677 throw new Error("initializeWasm() must be awaited first!");
20679 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
20680 return nativeResponseValue;
20682 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20684 export function OpenChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
20685 if(!isWasmInitialized) {
20686 throw new Error("initializeWasm() must be awaited first!");
20688 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
20689 // debug statements here
20691 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20693 export function OpenChannel_get_channel_flags(this_ptr: number): number {
20694 if(!isWasmInitialized) {
20695 throw new Error("initializeWasm() must be awaited first!");
20697 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
20698 return nativeResponseValue;
20700 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
20702 export function OpenChannel_set_channel_flags(this_ptr: number, val: number): void {
20703 if(!isWasmInitialized) {
20704 throw new Error("initializeWasm() must be awaited first!");
20706 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
20707 // debug statements here
20709 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20711 export function OpenChannel_get_channel_type(this_ptr: number): number {
20712 if(!isWasmInitialized) {
20713 throw new Error("initializeWasm() must be awaited first!");
20715 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
20716 return nativeResponseValue;
20718 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
20720 export function OpenChannel_set_channel_type(this_ptr: number, val: number): void {
20721 if(!isWasmInitialized) {
20722 throw new Error("initializeWasm() must be awaited first!");
20724 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
20725 // debug statements here
20727 // uintptr_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
20729 export function OpenChannel_clone_ptr(arg: number): number {
20730 if(!isWasmInitialized) {
20731 throw new Error("initializeWasm() must be awaited first!");
20733 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
20734 return nativeResponseValue;
20736 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
20738 export function OpenChannel_clone(orig: number): number {
20739 if(!isWasmInitialized) {
20740 throw new Error("initializeWasm() must be awaited first!");
20742 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
20743 return nativeResponseValue;
20745 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
20747 export function AcceptChannel_free(this_obj: number): void {
20748 if(!isWasmInitialized) {
20749 throw new Error("initializeWasm() must be awaited first!");
20751 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
20752 // debug statements here
20754 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
20756 export function AcceptChannel_get_temporary_channel_id(this_ptr: number): number {
20757 if(!isWasmInitialized) {
20758 throw new Error("initializeWasm() must be awaited first!");
20760 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
20761 return nativeResponseValue;
20763 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20765 export function AcceptChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
20766 if(!isWasmInitialized) {
20767 throw new Error("initializeWasm() must be awaited first!");
20769 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
20770 // debug statements here
20772 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20774 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
20775 if(!isWasmInitialized) {
20776 throw new Error("initializeWasm() must be awaited first!");
20778 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
20779 return nativeResponseValue;
20781 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20783 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
20784 if(!isWasmInitialized) {
20785 throw new Error("initializeWasm() must be awaited first!");
20787 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
20788 // debug statements here
20790 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20792 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
20793 if(!isWasmInitialized) {
20794 throw new Error("initializeWasm() must be awaited first!");
20796 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
20797 return nativeResponseValue;
20799 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20801 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
20802 if(!isWasmInitialized) {
20803 throw new Error("initializeWasm() must be awaited first!");
20805 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
20806 // debug statements here
20808 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20810 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
20811 if(!isWasmInitialized) {
20812 throw new Error("initializeWasm() must be awaited first!");
20814 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
20815 return nativeResponseValue;
20817 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20819 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
20820 if(!isWasmInitialized) {
20821 throw new Error("initializeWasm() must be awaited first!");
20823 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
20824 // debug statements here
20826 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20828 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
20829 if(!isWasmInitialized) {
20830 throw new Error("initializeWasm() must be awaited first!");
20832 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
20833 return nativeResponseValue;
20835 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
20837 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
20838 if(!isWasmInitialized) {
20839 throw new Error("initializeWasm() must be awaited first!");
20841 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
20842 // debug statements here
20844 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20846 export function AcceptChannel_get_minimum_depth(this_ptr: number): number {
20847 if(!isWasmInitialized) {
20848 throw new Error("initializeWasm() must be awaited first!");
20850 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
20851 return nativeResponseValue;
20853 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
20855 export function AcceptChannel_set_minimum_depth(this_ptr: number, val: number): void {
20856 if(!isWasmInitialized) {
20857 throw new Error("initializeWasm() must be awaited first!");
20859 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
20860 // debug statements here
20862 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20864 export function AcceptChannel_get_to_self_delay(this_ptr: number): number {
20865 if(!isWasmInitialized) {
20866 throw new Error("initializeWasm() must be awaited first!");
20868 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
20869 return nativeResponseValue;
20871 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
20873 export function AcceptChannel_set_to_self_delay(this_ptr: number, val: number): void {
20874 if(!isWasmInitialized) {
20875 throw new Error("initializeWasm() must be awaited first!");
20877 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
20878 // debug statements here
20880 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20882 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: number): number {
20883 if(!isWasmInitialized) {
20884 throw new Error("initializeWasm() must be awaited first!");
20886 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
20887 return nativeResponseValue;
20889 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
20891 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
20892 if(!isWasmInitialized) {
20893 throw new Error("initializeWasm() must be awaited first!");
20895 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
20896 // debug statements here
20898 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20900 export function AcceptChannel_get_funding_pubkey(this_ptr: number): number {
20901 if(!isWasmInitialized) {
20902 throw new Error("initializeWasm() must be awaited first!");
20904 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
20905 return nativeResponseValue;
20907 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20909 export function AcceptChannel_set_funding_pubkey(this_ptr: number, val: number): void {
20910 if(!isWasmInitialized) {
20911 throw new Error("initializeWasm() must be awaited first!");
20913 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
20914 // debug statements here
20916 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20918 export function AcceptChannel_get_revocation_basepoint(this_ptr: number): number {
20919 if(!isWasmInitialized) {
20920 throw new Error("initializeWasm() must be awaited first!");
20922 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
20923 return nativeResponseValue;
20925 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20927 export function AcceptChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
20928 if(!isWasmInitialized) {
20929 throw new Error("initializeWasm() must be awaited first!");
20931 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
20932 // debug statements here
20934 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20936 export function AcceptChannel_get_payment_point(this_ptr: number): number {
20937 if(!isWasmInitialized) {
20938 throw new Error("initializeWasm() must be awaited first!");
20940 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
20941 return nativeResponseValue;
20943 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20945 export function AcceptChannel_set_payment_point(this_ptr: number, val: number): void {
20946 if(!isWasmInitialized) {
20947 throw new Error("initializeWasm() must be awaited first!");
20949 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
20950 // debug statements here
20952 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20954 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: number): number {
20955 if(!isWasmInitialized) {
20956 throw new Error("initializeWasm() must be awaited first!");
20958 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
20959 return nativeResponseValue;
20961 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20963 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
20964 if(!isWasmInitialized) {
20965 throw new Error("initializeWasm() must be awaited first!");
20967 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
20968 // debug statements here
20970 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20972 export function AcceptChannel_get_htlc_basepoint(this_ptr: number): number {
20973 if(!isWasmInitialized) {
20974 throw new Error("initializeWasm() must be awaited first!");
20976 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
20977 return nativeResponseValue;
20979 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20981 export function AcceptChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
20982 if(!isWasmInitialized) {
20983 throw new Error("initializeWasm() must be awaited first!");
20985 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
20986 // debug statements here
20988 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
20990 export function AcceptChannel_get_first_per_commitment_point(this_ptr: number): number {
20991 if(!isWasmInitialized) {
20992 throw new Error("initializeWasm() must be awaited first!");
20994 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
20995 return nativeResponseValue;
20997 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20999 export function AcceptChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
21000 if(!isWasmInitialized) {
21001 throw new Error("initializeWasm() must be awaited first!");
21003 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
21004 // debug statements here
21006 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21008 export function AcceptChannel_get_channel_type(this_ptr: number): number {
21009 if(!isWasmInitialized) {
21010 throw new Error("initializeWasm() must be awaited first!");
21012 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
21013 return nativeResponseValue;
21015 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
21017 export function AcceptChannel_set_channel_type(this_ptr: number, val: number): void {
21018 if(!isWasmInitialized) {
21019 throw new Error("initializeWasm() must be awaited first!");
21021 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
21022 // debug statements here
21024 // uintptr_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
21026 export function AcceptChannel_clone_ptr(arg: number): number {
21027 if(!isWasmInitialized) {
21028 throw new Error("initializeWasm() must be awaited first!");
21030 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
21031 return nativeResponseValue;
21033 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
21035 export function AcceptChannel_clone(orig: number): number {
21036 if(!isWasmInitialized) {
21037 throw new Error("initializeWasm() must be awaited first!");
21039 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
21040 return nativeResponseValue;
21042 // void FundingCreated_free(struct LDKFundingCreated this_obj);
21044 export function FundingCreated_free(this_obj: number): void {
21045 if(!isWasmInitialized) {
21046 throw new Error("initializeWasm() must be awaited first!");
21048 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
21049 // debug statements here
21051 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21053 export function FundingCreated_get_temporary_channel_id(this_ptr: number): number {
21054 if(!isWasmInitialized) {
21055 throw new Error("initializeWasm() must be awaited first!");
21057 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
21058 return nativeResponseValue;
21060 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21062 export function FundingCreated_set_temporary_channel_id(this_ptr: number, val: number): void {
21063 if(!isWasmInitialized) {
21064 throw new Error("initializeWasm() must be awaited first!");
21066 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
21067 // debug statements here
21069 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21071 export function FundingCreated_get_funding_txid(this_ptr: number): number {
21072 if(!isWasmInitialized) {
21073 throw new Error("initializeWasm() must be awaited first!");
21075 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
21076 return nativeResponseValue;
21078 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21080 export function FundingCreated_set_funding_txid(this_ptr: number, val: number): void {
21081 if(!isWasmInitialized) {
21082 throw new Error("initializeWasm() must be awaited first!");
21084 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
21085 // debug statements here
21087 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21089 export function FundingCreated_get_funding_output_index(this_ptr: number): number {
21090 if(!isWasmInitialized) {
21091 throw new Error("initializeWasm() must be awaited first!");
21093 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
21094 return nativeResponseValue;
21096 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
21098 export function FundingCreated_set_funding_output_index(this_ptr: number, val: number): void {
21099 if(!isWasmInitialized) {
21100 throw new Error("initializeWasm() must be awaited first!");
21102 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
21103 // debug statements here
21105 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21107 export function FundingCreated_get_signature(this_ptr: number): number {
21108 if(!isWasmInitialized) {
21109 throw new Error("initializeWasm() must be awaited first!");
21111 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
21112 return nativeResponseValue;
21114 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
21116 export function FundingCreated_set_signature(this_ptr: number, val: number): void {
21117 if(!isWasmInitialized) {
21118 throw new Error("initializeWasm() must be awaited first!");
21120 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
21121 // debug statements here
21123 // 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);
21125 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): number {
21126 if(!isWasmInitialized) {
21127 throw new Error("initializeWasm() must be awaited first!");
21129 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
21130 return nativeResponseValue;
21132 // uintptr_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
21134 export function FundingCreated_clone_ptr(arg: number): number {
21135 if(!isWasmInitialized) {
21136 throw new Error("initializeWasm() must be awaited first!");
21138 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
21139 return nativeResponseValue;
21141 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
21143 export function FundingCreated_clone(orig: number): number {
21144 if(!isWasmInitialized) {
21145 throw new Error("initializeWasm() must be awaited first!");
21147 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
21148 return nativeResponseValue;
21150 // void FundingSigned_free(struct LDKFundingSigned this_obj);
21152 export function FundingSigned_free(this_obj: number): void {
21153 if(!isWasmInitialized) {
21154 throw new Error("initializeWasm() must be awaited first!");
21156 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
21157 // debug statements here
21159 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
21161 export function FundingSigned_get_channel_id(this_ptr: number): number {
21162 if(!isWasmInitialized) {
21163 throw new Error("initializeWasm() must be awaited first!");
21165 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
21166 return nativeResponseValue;
21168 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21170 export function FundingSigned_set_channel_id(this_ptr: number, val: number): void {
21171 if(!isWasmInitialized) {
21172 throw new Error("initializeWasm() must be awaited first!");
21174 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
21175 // debug statements here
21177 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
21179 export function FundingSigned_get_signature(this_ptr: number): number {
21180 if(!isWasmInitialized) {
21181 throw new Error("initializeWasm() must be awaited first!");
21183 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
21184 return nativeResponseValue;
21186 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21188 export function FundingSigned_set_signature(this_ptr: number, val: number): void {
21189 if(!isWasmInitialized) {
21190 throw new Error("initializeWasm() must be awaited first!");
21192 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
21193 // debug statements here
21195 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
21197 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): number {
21198 if(!isWasmInitialized) {
21199 throw new Error("initializeWasm() must be awaited first!");
21201 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
21202 return nativeResponseValue;
21204 // uintptr_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
21206 export function FundingSigned_clone_ptr(arg: number): number {
21207 if(!isWasmInitialized) {
21208 throw new Error("initializeWasm() must be awaited first!");
21210 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
21211 return nativeResponseValue;
21213 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
21215 export function FundingSigned_clone(orig: number): number {
21216 if(!isWasmInitialized) {
21217 throw new Error("initializeWasm() must be awaited first!");
21219 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
21220 return nativeResponseValue;
21222 // void ChannelReady_free(struct LDKChannelReady this_obj);
21224 export function ChannelReady_free(this_obj: number): void {
21225 if(!isWasmInitialized) {
21226 throw new Error("initializeWasm() must be awaited first!");
21228 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
21229 // debug statements here
21231 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
21233 export function ChannelReady_get_channel_id(this_ptr: number): number {
21234 if(!isWasmInitialized) {
21235 throw new Error("initializeWasm() must be awaited first!");
21237 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
21238 return nativeResponseValue;
21240 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21242 export function ChannelReady_set_channel_id(this_ptr: number, val: number): void {
21243 if(!isWasmInitialized) {
21244 throw new Error("initializeWasm() must be awaited first!");
21246 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
21247 // debug statements here
21249 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
21251 export function ChannelReady_get_next_per_commitment_point(this_ptr: number): number {
21252 if(!isWasmInitialized) {
21253 throw new Error("initializeWasm() must be awaited first!");
21255 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
21256 return nativeResponseValue;
21258 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21260 export function ChannelReady_set_next_per_commitment_point(this_ptr: number, val: number): void {
21261 if(!isWasmInitialized) {
21262 throw new Error("initializeWasm() must be awaited first!");
21264 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
21265 // debug statements here
21267 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
21269 export function ChannelReady_get_short_channel_id_alias(this_ptr: number): number {
21270 if(!isWasmInitialized) {
21271 throw new Error("initializeWasm() must be awaited first!");
21273 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
21274 return nativeResponseValue;
21276 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21278 export function ChannelReady_set_short_channel_id_alias(this_ptr: number, val: number): void {
21279 if(!isWasmInitialized) {
21280 throw new Error("initializeWasm() must be awaited first!");
21282 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
21283 // debug statements here
21285 // 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);
21287 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: number): number {
21288 if(!isWasmInitialized) {
21289 throw new Error("initializeWasm() must be awaited first!");
21291 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
21292 return nativeResponseValue;
21294 // uintptr_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
21296 export function ChannelReady_clone_ptr(arg: number): number {
21297 if(!isWasmInitialized) {
21298 throw new Error("initializeWasm() must be awaited first!");
21300 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
21301 return nativeResponseValue;
21303 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
21305 export function ChannelReady_clone(orig: number): number {
21306 if(!isWasmInitialized) {
21307 throw new Error("initializeWasm() must be awaited first!");
21309 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
21310 return nativeResponseValue;
21312 // void Shutdown_free(struct LDKShutdown this_obj);
21314 export function Shutdown_free(this_obj: number): void {
21315 if(!isWasmInitialized) {
21316 throw new Error("initializeWasm() must be awaited first!");
21318 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
21319 // debug statements here
21321 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
21323 export function Shutdown_get_channel_id(this_ptr: number): number {
21324 if(!isWasmInitialized) {
21325 throw new Error("initializeWasm() must be awaited first!");
21327 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
21328 return nativeResponseValue;
21330 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21332 export function Shutdown_set_channel_id(this_ptr: number, val: number): void {
21333 if(!isWasmInitialized) {
21334 throw new Error("initializeWasm() must be awaited first!");
21336 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
21337 // debug statements here
21339 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
21341 export function Shutdown_get_scriptpubkey(this_ptr: number): number {
21342 if(!isWasmInitialized) {
21343 throw new Error("initializeWasm() must be awaited first!");
21345 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
21346 return nativeResponseValue;
21348 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
21350 export function Shutdown_set_scriptpubkey(this_ptr: number, val: number): void {
21351 if(!isWasmInitialized) {
21352 throw new Error("initializeWasm() must be awaited first!");
21354 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
21355 // debug statements here
21357 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
21359 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): number {
21360 if(!isWasmInitialized) {
21361 throw new Error("initializeWasm() must be awaited first!");
21363 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
21364 return nativeResponseValue;
21366 // uintptr_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
21368 export function Shutdown_clone_ptr(arg: number): number {
21369 if(!isWasmInitialized) {
21370 throw new Error("initializeWasm() must be awaited first!");
21372 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
21373 return nativeResponseValue;
21375 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
21377 export function Shutdown_clone(orig: number): number {
21378 if(!isWasmInitialized) {
21379 throw new Error("initializeWasm() must be awaited first!");
21381 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
21382 return nativeResponseValue;
21384 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
21386 export function ClosingSignedFeeRange_free(this_obj: number): void {
21387 if(!isWasmInitialized) {
21388 throw new Error("initializeWasm() must be awaited first!");
21390 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
21391 // debug statements here
21393 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
21395 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: number): bigint {
21396 if(!isWasmInitialized) {
21397 throw new Error("initializeWasm() must be awaited first!");
21399 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
21400 return nativeResponseValue;
21402 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
21404 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: number, val: bigint): void {
21405 if(!isWasmInitialized) {
21406 throw new Error("initializeWasm() must be awaited first!");
21408 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
21409 // debug statements here
21411 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
21413 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: number): bigint {
21414 if(!isWasmInitialized) {
21415 throw new Error("initializeWasm() must be awaited first!");
21417 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
21418 return nativeResponseValue;
21420 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
21422 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: number, val: bigint): void {
21423 if(!isWasmInitialized) {
21424 throw new Error("initializeWasm() must be awaited first!");
21426 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
21427 // debug statements here
21429 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
21431 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): number {
21432 if(!isWasmInitialized) {
21433 throw new Error("initializeWasm() must be awaited first!");
21435 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
21436 return nativeResponseValue;
21438 // uintptr_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
21440 export function ClosingSignedFeeRange_clone_ptr(arg: number): number {
21441 if(!isWasmInitialized) {
21442 throw new Error("initializeWasm() must be awaited first!");
21444 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
21445 return nativeResponseValue;
21447 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
21449 export function ClosingSignedFeeRange_clone(orig: number): number {
21450 if(!isWasmInitialized) {
21451 throw new Error("initializeWasm() must be awaited first!");
21453 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
21454 return nativeResponseValue;
21456 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
21458 export function ClosingSigned_free(this_obj: number): void {
21459 if(!isWasmInitialized) {
21460 throw new Error("initializeWasm() must be awaited first!");
21462 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
21463 // debug statements here
21465 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
21467 export function ClosingSigned_get_channel_id(this_ptr: number): number {
21468 if(!isWasmInitialized) {
21469 throw new Error("initializeWasm() must be awaited first!");
21471 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
21472 return nativeResponseValue;
21474 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21476 export function ClosingSigned_set_channel_id(this_ptr: number, val: number): void {
21477 if(!isWasmInitialized) {
21478 throw new Error("initializeWasm() must be awaited first!");
21480 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
21481 // debug statements here
21483 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
21485 export function ClosingSigned_get_fee_satoshis(this_ptr: number): bigint {
21486 if(!isWasmInitialized) {
21487 throw new Error("initializeWasm() must be awaited first!");
21489 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
21490 return nativeResponseValue;
21492 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
21494 export function ClosingSigned_set_fee_satoshis(this_ptr: number, val: bigint): void {
21495 if(!isWasmInitialized) {
21496 throw new Error("initializeWasm() must be awaited first!");
21498 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
21499 // debug statements here
21501 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
21503 export function ClosingSigned_get_signature(this_ptr: number): number {
21504 if(!isWasmInitialized) {
21505 throw new Error("initializeWasm() must be awaited first!");
21507 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
21508 return nativeResponseValue;
21510 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21512 export function ClosingSigned_set_signature(this_ptr: number, val: number): void {
21513 if(!isWasmInitialized) {
21514 throw new Error("initializeWasm() must be awaited first!");
21516 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
21517 // debug statements here
21519 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
21521 export function ClosingSigned_get_fee_range(this_ptr: number): number {
21522 if(!isWasmInitialized) {
21523 throw new Error("initializeWasm() must be awaited first!");
21525 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
21526 return nativeResponseValue;
21528 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
21530 export function ClosingSigned_set_fee_range(this_ptr: number, val: number): void {
21531 if(!isWasmInitialized) {
21532 throw new Error("initializeWasm() must be awaited first!");
21534 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
21535 // debug statements here
21537 // 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);
21539 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: number): number {
21540 if(!isWasmInitialized) {
21541 throw new Error("initializeWasm() must be awaited first!");
21543 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
21544 return nativeResponseValue;
21546 // uintptr_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
21548 export function ClosingSigned_clone_ptr(arg: number): number {
21549 if(!isWasmInitialized) {
21550 throw new Error("initializeWasm() must be awaited first!");
21552 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
21553 return nativeResponseValue;
21555 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
21557 export function ClosingSigned_clone(orig: number): number {
21558 if(!isWasmInitialized) {
21559 throw new Error("initializeWasm() must be awaited first!");
21561 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
21562 return nativeResponseValue;
21564 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
21566 export function UpdateAddHTLC_free(this_obj: number): void {
21567 if(!isWasmInitialized) {
21568 throw new Error("initializeWasm() must be awaited first!");
21570 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
21571 // debug statements here
21573 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
21575 export function UpdateAddHTLC_get_channel_id(this_ptr: number): number {
21576 if(!isWasmInitialized) {
21577 throw new Error("initializeWasm() must be awaited first!");
21579 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
21580 return nativeResponseValue;
21582 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21584 export function UpdateAddHTLC_set_channel_id(this_ptr: number, val: number): void {
21585 if(!isWasmInitialized) {
21586 throw new Error("initializeWasm() must be awaited first!");
21588 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
21589 // debug statements here
21591 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21593 export function UpdateAddHTLC_get_htlc_id(this_ptr: number): bigint {
21594 if(!isWasmInitialized) {
21595 throw new Error("initializeWasm() must be awaited first!");
21597 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
21598 return nativeResponseValue;
21600 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
21602 export function UpdateAddHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21603 if(!isWasmInitialized) {
21604 throw new Error("initializeWasm() must be awaited first!");
21606 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
21607 // debug statements here
21609 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21611 export function UpdateAddHTLC_get_amount_msat(this_ptr: number): bigint {
21612 if(!isWasmInitialized) {
21613 throw new Error("initializeWasm() must be awaited first!");
21615 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
21616 return nativeResponseValue;
21618 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
21620 export function UpdateAddHTLC_set_amount_msat(this_ptr: number, val: bigint): void {
21621 if(!isWasmInitialized) {
21622 throw new Error("initializeWasm() must be awaited first!");
21624 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
21625 // debug statements here
21627 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
21629 export function UpdateAddHTLC_get_payment_hash(this_ptr: number): number {
21630 if(!isWasmInitialized) {
21631 throw new Error("initializeWasm() must be awaited first!");
21633 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
21634 return nativeResponseValue;
21636 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21638 export function UpdateAddHTLC_set_payment_hash(this_ptr: number, val: number): void {
21639 if(!isWasmInitialized) {
21640 throw new Error("initializeWasm() must be awaited first!");
21642 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
21643 // debug statements here
21645 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21647 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: number): number {
21648 if(!isWasmInitialized) {
21649 throw new Error("initializeWasm() must be awaited first!");
21651 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
21652 return nativeResponseValue;
21654 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
21656 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: number, val: number): void {
21657 if(!isWasmInitialized) {
21658 throw new Error("initializeWasm() must be awaited first!");
21660 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
21661 // debug statements here
21663 // uintptr_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
21665 export function UpdateAddHTLC_clone_ptr(arg: number): number {
21666 if(!isWasmInitialized) {
21667 throw new Error("initializeWasm() must be awaited first!");
21669 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
21670 return nativeResponseValue;
21672 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
21674 export function UpdateAddHTLC_clone(orig: number): number {
21675 if(!isWasmInitialized) {
21676 throw new Error("initializeWasm() must be awaited first!");
21678 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
21679 return nativeResponseValue;
21681 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
21683 export function UpdateFulfillHTLC_free(this_obj: number): void {
21684 if(!isWasmInitialized) {
21685 throw new Error("initializeWasm() must be awaited first!");
21687 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
21688 // debug statements here
21690 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
21692 export function UpdateFulfillHTLC_get_channel_id(this_ptr: number): number {
21693 if(!isWasmInitialized) {
21694 throw new Error("initializeWasm() must be awaited first!");
21696 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
21697 return nativeResponseValue;
21699 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21701 export function UpdateFulfillHTLC_set_channel_id(this_ptr: number, val: number): void {
21702 if(!isWasmInitialized) {
21703 throw new Error("initializeWasm() must be awaited first!");
21705 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
21706 // debug statements here
21708 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
21710 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: number): bigint {
21711 if(!isWasmInitialized) {
21712 throw new Error("initializeWasm() must be awaited first!");
21714 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
21715 return nativeResponseValue;
21717 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
21719 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21720 if(!isWasmInitialized) {
21721 throw new Error("initializeWasm() must be awaited first!");
21723 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
21724 // debug statements here
21726 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
21728 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: number): number {
21729 if(!isWasmInitialized) {
21730 throw new Error("initializeWasm() must be awaited first!");
21732 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
21733 return nativeResponseValue;
21735 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21737 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: number, val: number): void {
21738 if(!isWasmInitialized) {
21739 throw new Error("initializeWasm() must be awaited first!");
21741 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
21742 // debug statements here
21744 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
21746 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): number {
21747 if(!isWasmInitialized) {
21748 throw new Error("initializeWasm() must be awaited first!");
21750 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
21751 return nativeResponseValue;
21753 // uintptr_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
21755 export function UpdateFulfillHTLC_clone_ptr(arg: number): number {
21756 if(!isWasmInitialized) {
21757 throw new Error("initializeWasm() must be awaited first!");
21759 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
21760 return nativeResponseValue;
21762 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
21764 export function UpdateFulfillHTLC_clone(orig: number): number {
21765 if(!isWasmInitialized) {
21766 throw new Error("initializeWasm() must be awaited first!");
21768 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
21769 return nativeResponseValue;
21771 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
21773 export function UpdateFailHTLC_free(this_obj: number): void {
21774 if(!isWasmInitialized) {
21775 throw new Error("initializeWasm() must be awaited first!");
21777 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
21778 // debug statements here
21780 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
21782 export function UpdateFailHTLC_get_channel_id(this_ptr: number): number {
21783 if(!isWasmInitialized) {
21784 throw new Error("initializeWasm() must be awaited first!");
21786 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
21787 return nativeResponseValue;
21789 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21791 export function UpdateFailHTLC_set_channel_id(this_ptr: number, val: number): void {
21792 if(!isWasmInitialized) {
21793 throw new Error("initializeWasm() must be awaited first!");
21795 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
21796 // debug statements here
21798 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
21800 export function UpdateFailHTLC_get_htlc_id(this_ptr: number): bigint {
21801 if(!isWasmInitialized) {
21802 throw new Error("initializeWasm() must be awaited first!");
21804 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
21805 return nativeResponseValue;
21807 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
21809 export function UpdateFailHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21810 if(!isWasmInitialized) {
21811 throw new Error("initializeWasm() must be awaited first!");
21813 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
21814 // debug statements here
21816 // uintptr_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
21818 export function UpdateFailHTLC_clone_ptr(arg: number): number {
21819 if(!isWasmInitialized) {
21820 throw new Error("initializeWasm() must be awaited first!");
21822 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
21823 return nativeResponseValue;
21825 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
21827 export function UpdateFailHTLC_clone(orig: number): number {
21828 if(!isWasmInitialized) {
21829 throw new Error("initializeWasm() must be awaited first!");
21831 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
21832 return nativeResponseValue;
21834 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
21836 export function UpdateFailMalformedHTLC_free(this_obj: number): void {
21837 if(!isWasmInitialized) {
21838 throw new Error("initializeWasm() must be awaited first!");
21840 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
21841 // debug statements here
21843 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
21845 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: number): number {
21846 if(!isWasmInitialized) {
21847 throw new Error("initializeWasm() must be awaited first!");
21849 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
21850 return nativeResponseValue;
21852 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21854 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: number, val: number): void {
21855 if(!isWasmInitialized) {
21856 throw new Error("initializeWasm() must be awaited first!");
21858 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
21859 // debug statements here
21861 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
21863 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: number): bigint {
21864 if(!isWasmInitialized) {
21865 throw new Error("initializeWasm() must be awaited first!");
21867 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
21868 return nativeResponseValue;
21870 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
21872 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21873 if(!isWasmInitialized) {
21874 throw new Error("initializeWasm() must be awaited first!");
21876 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
21877 // debug statements here
21879 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
21881 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: number): number {
21882 if(!isWasmInitialized) {
21883 throw new Error("initializeWasm() must be awaited first!");
21885 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
21886 return nativeResponseValue;
21888 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
21890 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: number, val: number): void {
21891 if(!isWasmInitialized) {
21892 throw new Error("initializeWasm() must be awaited first!");
21894 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
21895 // debug statements here
21897 // uintptr_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
21899 export function UpdateFailMalformedHTLC_clone_ptr(arg: number): number {
21900 if(!isWasmInitialized) {
21901 throw new Error("initializeWasm() must be awaited first!");
21903 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
21904 return nativeResponseValue;
21906 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
21908 export function UpdateFailMalformedHTLC_clone(orig: number): number {
21909 if(!isWasmInitialized) {
21910 throw new Error("initializeWasm() must be awaited first!");
21912 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
21913 return nativeResponseValue;
21915 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
21917 export function CommitmentSigned_free(this_obj: number): void {
21918 if(!isWasmInitialized) {
21919 throw new Error("initializeWasm() must be awaited first!");
21921 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
21922 // debug statements here
21924 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
21926 export function CommitmentSigned_get_channel_id(this_ptr: number): number {
21927 if(!isWasmInitialized) {
21928 throw new Error("initializeWasm() must be awaited first!");
21930 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
21931 return nativeResponseValue;
21933 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21935 export function CommitmentSigned_set_channel_id(this_ptr: number, val: number): void {
21936 if(!isWasmInitialized) {
21937 throw new Error("initializeWasm() must be awaited first!");
21939 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
21940 // debug statements here
21942 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
21944 export function CommitmentSigned_get_signature(this_ptr: number): number {
21945 if(!isWasmInitialized) {
21946 throw new Error("initializeWasm() must be awaited first!");
21948 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
21949 return nativeResponseValue;
21951 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21953 export function CommitmentSigned_set_signature(this_ptr: number, val: number): void {
21954 if(!isWasmInitialized) {
21955 throw new Error("initializeWasm() must be awaited first!");
21957 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
21958 // debug statements here
21960 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
21962 export function CommitmentSigned_set_htlc_signatures(this_ptr: number, val: number): void {
21963 if(!isWasmInitialized) {
21964 throw new Error("initializeWasm() must be awaited first!");
21966 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
21967 // debug statements here
21969 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
21971 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): number {
21972 if(!isWasmInitialized) {
21973 throw new Error("initializeWasm() must be awaited first!");
21975 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
21976 return nativeResponseValue;
21978 // uintptr_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
21980 export function CommitmentSigned_clone_ptr(arg: number): number {
21981 if(!isWasmInitialized) {
21982 throw new Error("initializeWasm() must be awaited first!");
21984 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
21985 return nativeResponseValue;
21987 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
21989 export function CommitmentSigned_clone(orig: number): number {
21990 if(!isWasmInitialized) {
21991 throw new Error("initializeWasm() must be awaited first!");
21993 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
21994 return nativeResponseValue;
21996 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
21998 export function RevokeAndACK_free(this_obj: number): void {
21999 if(!isWasmInitialized) {
22000 throw new Error("initializeWasm() must be awaited first!");
22002 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
22003 // debug statements here
22005 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22007 export function RevokeAndACK_get_channel_id(this_ptr: number): number {
22008 if(!isWasmInitialized) {
22009 throw new Error("initializeWasm() must be awaited first!");
22011 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
22012 return nativeResponseValue;
22014 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22016 export function RevokeAndACK_set_channel_id(this_ptr: number, val: number): void {
22017 if(!isWasmInitialized) {
22018 throw new Error("initializeWasm() must be awaited first!");
22020 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
22021 // debug statements here
22023 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22025 export function RevokeAndACK_get_per_commitment_secret(this_ptr: number): number {
22026 if(!isWasmInitialized) {
22027 throw new Error("initializeWasm() must be awaited first!");
22029 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
22030 return nativeResponseValue;
22032 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22034 export function RevokeAndACK_set_per_commitment_secret(this_ptr: number, val: number): void {
22035 if(!isWasmInitialized) {
22036 throw new Error("initializeWasm() must be awaited first!");
22038 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
22039 // debug statements here
22041 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
22043 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: number): number {
22044 if(!isWasmInitialized) {
22045 throw new Error("initializeWasm() must be awaited first!");
22047 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
22048 return nativeResponseValue;
22050 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22052 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: number, val: number): void {
22053 if(!isWasmInitialized) {
22054 throw new Error("initializeWasm() must be awaited first!");
22056 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
22057 // debug statements here
22059 // 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);
22061 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): number {
22062 if(!isWasmInitialized) {
22063 throw new Error("initializeWasm() must be awaited first!");
22065 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
22066 return nativeResponseValue;
22068 // uintptr_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
22070 export function RevokeAndACK_clone_ptr(arg: number): number {
22071 if(!isWasmInitialized) {
22072 throw new Error("initializeWasm() must be awaited first!");
22074 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
22075 return nativeResponseValue;
22077 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
22079 export function RevokeAndACK_clone(orig: number): number {
22080 if(!isWasmInitialized) {
22081 throw new Error("initializeWasm() must be awaited first!");
22083 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
22084 return nativeResponseValue;
22086 // void UpdateFee_free(struct LDKUpdateFee this_obj);
22088 export function UpdateFee_free(this_obj: number): void {
22089 if(!isWasmInitialized) {
22090 throw new Error("initializeWasm() must be awaited first!");
22092 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
22093 // debug statements here
22095 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
22097 export function UpdateFee_get_channel_id(this_ptr: number): number {
22098 if(!isWasmInitialized) {
22099 throw new Error("initializeWasm() must be awaited first!");
22101 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
22102 return nativeResponseValue;
22104 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22106 export function UpdateFee_set_channel_id(this_ptr: number, val: number): void {
22107 if(!isWasmInitialized) {
22108 throw new Error("initializeWasm() must be awaited first!");
22110 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
22111 // debug statements here
22113 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
22115 export function UpdateFee_get_feerate_per_kw(this_ptr: number): number {
22116 if(!isWasmInitialized) {
22117 throw new Error("initializeWasm() must be awaited first!");
22119 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
22120 return nativeResponseValue;
22122 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
22124 export function UpdateFee_set_feerate_per_kw(this_ptr: number, val: number): void {
22125 if(!isWasmInitialized) {
22126 throw new Error("initializeWasm() must be awaited first!");
22128 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
22129 // debug statements here
22131 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
22133 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): number {
22134 if(!isWasmInitialized) {
22135 throw new Error("initializeWasm() must be awaited first!");
22137 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
22138 return nativeResponseValue;
22140 // uintptr_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
22142 export function UpdateFee_clone_ptr(arg: number): number {
22143 if(!isWasmInitialized) {
22144 throw new Error("initializeWasm() must be awaited first!");
22146 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
22147 return nativeResponseValue;
22149 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
22151 export function UpdateFee_clone(orig: number): number {
22152 if(!isWasmInitialized) {
22153 throw new Error("initializeWasm() must be awaited first!");
22155 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
22156 return nativeResponseValue;
22158 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
22160 export function DataLossProtect_free(this_obj: number): void {
22161 if(!isWasmInitialized) {
22162 throw new Error("initializeWasm() must be awaited first!");
22164 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
22165 // debug statements here
22167 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
22169 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: number): number {
22170 if(!isWasmInitialized) {
22171 throw new Error("initializeWasm() must be awaited first!");
22173 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
22174 return nativeResponseValue;
22176 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22178 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: number, val: number): void {
22179 if(!isWasmInitialized) {
22180 throw new Error("initializeWasm() must be awaited first!");
22182 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
22183 // debug statements here
22185 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
22187 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: number): number {
22188 if(!isWasmInitialized) {
22189 throw new Error("initializeWasm() must be awaited first!");
22191 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
22192 return nativeResponseValue;
22194 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22196 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: number, val: number): void {
22197 if(!isWasmInitialized) {
22198 throw new Error("initializeWasm() must be awaited first!");
22200 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
22201 // debug statements here
22203 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
22205 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): number {
22206 if(!isWasmInitialized) {
22207 throw new Error("initializeWasm() must be awaited first!");
22209 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
22210 return nativeResponseValue;
22212 // uintptr_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
22214 export function DataLossProtect_clone_ptr(arg: number): number {
22215 if(!isWasmInitialized) {
22216 throw new Error("initializeWasm() must be awaited first!");
22218 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
22219 return nativeResponseValue;
22221 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
22223 export function DataLossProtect_clone(orig: number): number {
22224 if(!isWasmInitialized) {
22225 throw new Error("initializeWasm() must be awaited first!");
22227 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
22228 return nativeResponseValue;
22230 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
22232 export function ChannelReestablish_free(this_obj: number): void {
22233 if(!isWasmInitialized) {
22234 throw new Error("initializeWasm() must be awaited first!");
22236 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
22237 // debug statements here
22239 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
22241 export function ChannelReestablish_get_channel_id(this_ptr: number): number {
22242 if(!isWasmInitialized) {
22243 throw new Error("initializeWasm() must be awaited first!");
22245 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
22246 return nativeResponseValue;
22248 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22250 export function ChannelReestablish_set_channel_id(this_ptr: number, val: number): void {
22251 if(!isWasmInitialized) {
22252 throw new Error("initializeWasm() must be awaited first!");
22254 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
22255 // debug statements here
22257 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
22259 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: number): bigint {
22260 if(!isWasmInitialized) {
22261 throw new Error("initializeWasm() must be awaited first!");
22263 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
22264 return nativeResponseValue;
22266 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
22268 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: number, val: bigint): void {
22269 if(!isWasmInitialized) {
22270 throw new Error("initializeWasm() must be awaited first!");
22272 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
22273 // debug statements here
22275 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
22277 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: number): bigint {
22278 if(!isWasmInitialized) {
22279 throw new Error("initializeWasm() must be awaited first!");
22281 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
22282 return nativeResponseValue;
22284 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
22286 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: number, val: bigint): void {
22287 if(!isWasmInitialized) {
22288 throw new Error("initializeWasm() must be awaited first!");
22290 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
22291 // debug statements here
22293 // uintptr_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
22295 export function ChannelReestablish_clone_ptr(arg: number): number {
22296 if(!isWasmInitialized) {
22297 throw new Error("initializeWasm() must be awaited first!");
22299 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
22300 return nativeResponseValue;
22302 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
22304 export function ChannelReestablish_clone(orig: number): number {
22305 if(!isWasmInitialized) {
22306 throw new Error("initializeWasm() must be awaited first!");
22308 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
22309 return nativeResponseValue;
22311 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
22313 export function AnnouncementSignatures_free(this_obj: number): void {
22314 if(!isWasmInitialized) {
22315 throw new Error("initializeWasm() must be awaited first!");
22317 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
22318 // debug statements here
22320 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
22322 export function AnnouncementSignatures_get_channel_id(this_ptr: number): number {
22323 if(!isWasmInitialized) {
22324 throw new Error("initializeWasm() must be awaited first!");
22326 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
22327 return nativeResponseValue;
22329 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22331 export function AnnouncementSignatures_set_channel_id(this_ptr: number, val: number): void {
22332 if(!isWasmInitialized) {
22333 throw new Error("initializeWasm() must be awaited first!");
22335 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
22336 // debug statements here
22338 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
22340 export function AnnouncementSignatures_get_short_channel_id(this_ptr: number): bigint {
22341 if(!isWasmInitialized) {
22342 throw new Error("initializeWasm() must be awaited first!");
22344 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
22345 return nativeResponseValue;
22347 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
22349 export function AnnouncementSignatures_set_short_channel_id(this_ptr: number, val: bigint): void {
22350 if(!isWasmInitialized) {
22351 throw new Error("initializeWasm() must be awaited first!");
22353 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
22354 // debug statements here
22356 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
22358 export function AnnouncementSignatures_get_node_signature(this_ptr: number): number {
22359 if(!isWasmInitialized) {
22360 throw new Error("initializeWasm() must be awaited first!");
22362 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
22363 return nativeResponseValue;
22365 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
22367 export function AnnouncementSignatures_set_node_signature(this_ptr: number, val: number): void {
22368 if(!isWasmInitialized) {
22369 throw new Error("initializeWasm() must be awaited first!");
22371 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
22372 // debug statements here
22374 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
22376 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: number): number {
22377 if(!isWasmInitialized) {
22378 throw new Error("initializeWasm() must be awaited first!");
22380 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
22381 return nativeResponseValue;
22383 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
22385 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: number, val: number): void {
22386 if(!isWasmInitialized) {
22387 throw new Error("initializeWasm() must be awaited first!");
22389 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
22390 // debug statements here
22392 // 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);
22394 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): number {
22395 if(!isWasmInitialized) {
22396 throw new Error("initializeWasm() must be awaited first!");
22398 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
22399 return nativeResponseValue;
22401 // uintptr_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
22403 export function AnnouncementSignatures_clone_ptr(arg: number): number {
22404 if(!isWasmInitialized) {
22405 throw new Error("initializeWasm() must be awaited first!");
22407 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
22408 return nativeResponseValue;
22410 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
22412 export function AnnouncementSignatures_clone(orig: number): number {
22413 if(!isWasmInitialized) {
22414 throw new Error("initializeWasm() must be awaited first!");
22416 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
22417 return nativeResponseValue;
22419 // void NetAddress_free(struct LDKNetAddress this_ptr);
22421 export function NetAddress_free(this_ptr: number): void {
22422 if(!isWasmInitialized) {
22423 throw new Error("initializeWasm() must be awaited first!");
22425 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
22426 // debug statements here
22428 // uintptr_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
22430 export function NetAddress_clone_ptr(arg: number): number {
22431 if(!isWasmInitialized) {
22432 throw new Error("initializeWasm() must be awaited first!");
22434 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
22435 return nativeResponseValue;
22437 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
22439 export function NetAddress_clone(orig: number): number {
22440 if(!isWasmInitialized) {
22441 throw new Error("initializeWasm() must be awaited first!");
22443 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
22444 return nativeResponseValue;
22446 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
22448 export function NetAddress_ipv4(addr: number, port: number): number {
22449 if(!isWasmInitialized) {
22450 throw new Error("initializeWasm() must be awaited first!");
22452 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
22453 return nativeResponseValue;
22455 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
22457 export function NetAddress_ipv6(addr: number, port: number): number {
22458 if(!isWasmInitialized) {
22459 throw new Error("initializeWasm() must be awaited first!");
22461 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
22462 return nativeResponseValue;
22464 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
22466 export function NetAddress_onion_v2(a: number): number {
22467 if(!isWasmInitialized) {
22468 throw new Error("initializeWasm() must be awaited first!");
22470 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
22471 return nativeResponseValue;
22473 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
22475 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): number {
22476 if(!isWasmInitialized) {
22477 throw new Error("initializeWasm() must be awaited first!");
22479 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
22480 return nativeResponseValue;
22482 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
22484 export function NetAddress_write(obj: number): number {
22485 if(!isWasmInitialized) {
22486 throw new Error("initializeWasm() must be awaited first!");
22488 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
22489 return nativeResponseValue;
22491 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
22493 export function NetAddress_read(ser: number): number {
22494 if(!isWasmInitialized) {
22495 throw new Error("initializeWasm() must be awaited first!");
22497 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
22498 return nativeResponseValue;
22500 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
22502 export function UnsignedNodeAnnouncement_free(this_obj: number): void {
22503 if(!isWasmInitialized) {
22504 throw new Error("initializeWasm() must be awaited first!");
22506 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
22507 // debug statements here
22509 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
22511 export function UnsignedNodeAnnouncement_get_features(this_ptr: number): number {
22512 if(!isWasmInitialized) {
22513 throw new Error("initializeWasm() must be awaited first!");
22515 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
22516 return nativeResponseValue;
22518 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
22520 export function UnsignedNodeAnnouncement_set_features(this_ptr: number, val: number): void {
22521 if(!isWasmInitialized) {
22522 throw new Error("initializeWasm() must be awaited first!");
22524 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
22525 // debug statements here
22527 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
22529 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: number): number {
22530 if(!isWasmInitialized) {
22531 throw new Error("initializeWasm() must be awaited first!");
22533 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
22534 return nativeResponseValue;
22536 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
22538 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: number, val: number): void {
22539 if(!isWasmInitialized) {
22540 throw new Error("initializeWasm() must be awaited first!");
22542 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
22543 // debug statements here
22545 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
22547 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: number): number {
22548 if(!isWasmInitialized) {
22549 throw new Error("initializeWasm() must be awaited first!");
22551 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
22552 return nativeResponseValue;
22554 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22556 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: number, val: number): void {
22557 if(!isWasmInitialized) {
22558 throw new Error("initializeWasm() must be awaited first!");
22560 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
22561 // debug statements here
22563 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
22565 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: number): number {
22566 if(!isWasmInitialized) {
22567 throw new Error("initializeWasm() must be awaited first!");
22569 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
22570 return nativeResponseValue;
22572 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
22574 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: number, val: number): void {
22575 if(!isWasmInitialized) {
22576 throw new Error("initializeWasm() must be awaited first!");
22578 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
22579 // debug statements here
22581 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
22583 export function UnsignedNodeAnnouncement_get_alias(this_ptr: number): number {
22584 if(!isWasmInitialized) {
22585 throw new Error("initializeWasm() must be awaited first!");
22587 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
22588 return nativeResponseValue;
22590 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22592 export function UnsignedNodeAnnouncement_set_alias(this_ptr: number, val: number): void {
22593 if(!isWasmInitialized) {
22594 throw new Error("initializeWasm() must be awaited first!");
22596 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
22597 // debug statements here
22599 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
22601 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: number, val: number): void {
22602 if(!isWasmInitialized) {
22603 throw new Error("initializeWasm() must be awaited first!");
22605 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
22606 // debug statements here
22608 // uintptr_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
22610 export function UnsignedNodeAnnouncement_clone_ptr(arg: number): number {
22611 if(!isWasmInitialized) {
22612 throw new Error("initializeWasm() must be awaited first!");
22614 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
22615 return nativeResponseValue;
22617 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
22619 export function UnsignedNodeAnnouncement_clone(orig: number): number {
22620 if(!isWasmInitialized) {
22621 throw new Error("initializeWasm() must be awaited first!");
22623 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
22624 return nativeResponseValue;
22626 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
22628 export function NodeAnnouncement_free(this_obj: number): void {
22629 if(!isWasmInitialized) {
22630 throw new Error("initializeWasm() must be awaited first!");
22632 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
22633 // debug statements here
22635 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
22637 export function NodeAnnouncement_get_signature(this_ptr: number): number {
22638 if(!isWasmInitialized) {
22639 throw new Error("initializeWasm() must be awaited first!");
22641 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
22642 return nativeResponseValue;
22644 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22646 export function NodeAnnouncement_set_signature(this_ptr: number, val: number): void {
22647 if(!isWasmInitialized) {
22648 throw new Error("initializeWasm() must be awaited first!");
22650 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
22651 // debug statements here
22653 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
22655 export function NodeAnnouncement_get_contents(this_ptr: number): number {
22656 if(!isWasmInitialized) {
22657 throw new Error("initializeWasm() must be awaited first!");
22659 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
22660 return nativeResponseValue;
22662 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
22664 export function NodeAnnouncement_set_contents(this_ptr: number, val: number): void {
22665 if(!isWasmInitialized) {
22666 throw new Error("initializeWasm() must be awaited first!");
22668 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
22669 // debug statements here
22671 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
22673 export function NodeAnnouncement_new(signature_arg: number, contents_arg: number): number {
22674 if(!isWasmInitialized) {
22675 throw new Error("initializeWasm() must be awaited first!");
22677 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
22678 return nativeResponseValue;
22680 // uintptr_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
22682 export function NodeAnnouncement_clone_ptr(arg: number): number {
22683 if(!isWasmInitialized) {
22684 throw new Error("initializeWasm() must be awaited first!");
22686 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
22687 return nativeResponseValue;
22689 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
22691 export function NodeAnnouncement_clone(orig: number): number {
22692 if(!isWasmInitialized) {
22693 throw new Error("initializeWasm() must be awaited first!");
22695 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
22696 return nativeResponseValue;
22698 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
22700 export function UnsignedChannelAnnouncement_free(this_obj: number): void {
22701 if(!isWasmInitialized) {
22702 throw new Error("initializeWasm() must be awaited first!");
22704 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
22705 // debug statements here
22707 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22709 export function UnsignedChannelAnnouncement_get_features(this_ptr: number): number {
22710 if(!isWasmInitialized) {
22711 throw new Error("initializeWasm() must be awaited first!");
22713 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
22714 return nativeResponseValue;
22716 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
22718 export function UnsignedChannelAnnouncement_set_features(this_ptr: number, val: number): void {
22719 if(!isWasmInitialized) {
22720 throw new Error("initializeWasm() must be awaited first!");
22722 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
22723 // debug statements here
22725 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
22727 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: number): number {
22728 if(!isWasmInitialized) {
22729 throw new Error("initializeWasm() must be awaited first!");
22731 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
22732 return nativeResponseValue;
22734 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22736 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: number, val: number): void {
22737 if(!isWasmInitialized) {
22738 throw new Error("initializeWasm() must be awaited first!");
22740 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
22741 // debug statements here
22743 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22745 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: number): bigint {
22746 if(!isWasmInitialized) {
22747 throw new Error("initializeWasm() must be awaited first!");
22749 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
22750 return nativeResponseValue;
22752 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
22754 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: number, val: bigint): void {
22755 if(!isWasmInitialized) {
22756 throw new Error("initializeWasm() must be awaited first!");
22758 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
22759 // debug statements here
22761 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22763 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: number): number {
22764 if(!isWasmInitialized) {
22765 throw new Error("initializeWasm() must be awaited first!");
22767 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
22768 return nativeResponseValue;
22770 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22772 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: number, val: number): void {
22773 if(!isWasmInitialized) {
22774 throw new Error("initializeWasm() must be awaited first!");
22776 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
22777 // debug statements here
22779 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22781 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: number): number {
22782 if(!isWasmInitialized) {
22783 throw new Error("initializeWasm() must be awaited first!");
22785 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
22786 return nativeResponseValue;
22788 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22790 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: number, val: number): void {
22791 if(!isWasmInitialized) {
22792 throw new Error("initializeWasm() must be awaited first!");
22794 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
22795 // debug statements here
22797 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22799 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: number): number {
22800 if(!isWasmInitialized) {
22801 throw new Error("initializeWasm() must be awaited first!");
22803 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
22804 return nativeResponseValue;
22806 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22808 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: number, val: number): void {
22809 if(!isWasmInitialized) {
22810 throw new Error("initializeWasm() must be awaited first!");
22812 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
22813 // debug statements here
22815 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22817 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: number): number {
22818 if(!isWasmInitialized) {
22819 throw new Error("initializeWasm() must be awaited first!");
22821 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
22822 return nativeResponseValue;
22824 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22826 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: number, val: number): void {
22827 if(!isWasmInitialized) {
22828 throw new Error("initializeWasm() must be awaited first!");
22830 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
22831 // debug statements here
22833 // uintptr_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
22835 export function UnsignedChannelAnnouncement_clone_ptr(arg: number): number {
22836 if(!isWasmInitialized) {
22837 throw new Error("initializeWasm() must be awaited first!");
22839 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
22840 return nativeResponseValue;
22842 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
22844 export function UnsignedChannelAnnouncement_clone(orig: number): number {
22845 if(!isWasmInitialized) {
22846 throw new Error("initializeWasm() must be awaited first!");
22848 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
22849 return nativeResponseValue;
22851 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
22853 export function ChannelAnnouncement_free(this_obj: number): void {
22854 if(!isWasmInitialized) {
22855 throw new Error("initializeWasm() must be awaited first!");
22857 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
22858 // debug statements here
22860 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22862 export function ChannelAnnouncement_get_node_signature_1(this_ptr: number): number {
22863 if(!isWasmInitialized) {
22864 throw new Error("initializeWasm() must be awaited first!");
22866 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
22867 return nativeResponseValue;
22869 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22871 export function ChannelAnnouncement_set_node_signature_1(this_ptr: number, val: number): void {
22872 if(!isWasmInitialized) {
22873 throw new Error("initializeWasm() must be awaited first!");
22875 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
22876 // debug statements here
22878 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22880 export function ChannelAnnouncement_get_node_signature_2(this_ptr: number): number {
22881 if(!isWasmInitialized) {
22882 throw new Error("initializeWasm() must be awaited first!");
22884 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
22885 return nativeResponseValue;
22887 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22889 export function ChannelAnnouncement_set_node_signature_2(this_ptr: number, val: number): void {
22890 if(!isWasmInitialized) {
22891 throw new Error("initializeWasm() must be awaited first!");
22893 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
22894 // debug statements here
22896 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22898 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: number): number {
22899 if(!isWasmInitialized) {
22900 throw new Error("initializeWasm() must be awaited first!");
22902 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
22903 return nativeResponseValue;
22905 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22907 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: number, val: number): void {
22908 if(!isWasmInitialized) {
22909 throw new Error("initializeWasm() must be awaited first!");
22911 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
22912 // debug statements here
22914 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22916 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: number): number {
22917 if(!isWasmInitialized) {
22918 throw new Error("initializeWasm() must be awaited first!");
22920 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
22921 return nativeResponseValue;
22923 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22925 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: number, val: number): void {
22926 if(!isWasmInitialized) {
22927 throw new Error("initializeWasm() must be awaited first!");
22929 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
22930 // debug statements here
22932 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
22934 export function ChannelAnnouncement_get_contents(this_ptr: number): number {
22935 if(!isWasmInitialized) {
22936 throw new Error("initializeWasm() must be awaited first!");
22938 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
22939 return nativeResponseValue;
22941 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
22943 export function ChannelAnnouncement_set_contents(this_ptr: number, val: number): void {
22944 if(!isWasmInitialized) {
22945 throw new Error("initializeWasm() must be awaited first!");
22947 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
22948 // debug statements here
22950 // 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);
22952 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 {
22953 if(!isWasmInitialized) {
22954 throw new Error("initializeWasm() must be awaited first!");
22956 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
22957 return nativeResponseValue;
22959 // uintptr_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
22961 export function ChannelAnnouncement_clone_ptr(arg: number): number {
22962 if(!isWasmInitialized) {
22963 throw new Error("initializeWasm() must be awaited first!");
22965 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
22966 return nativeResponseValue;
22968 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
22970 export function ChannelAnnouncement_clone(orig: number): number {
22971 if(!isWasmInitialized) {
22972 throw new Error("initializeWasm() must be awaited first!");
22974 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
22975 return nativeResponseValue;
22977 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
22979 export function UnsignedChannelUpdate_free(this_obj: number): void {
22980 if(!isWasmInitialized) {
22981 throw new Error("initializeWasm() must be awaited first!");
22983 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
22984 // debug statements here
22986 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
22988 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: number): number {
22989 if(!isWasmInitialized) {
22990 throw new Error("initializeWasm() must be awaited first!");
22992 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
22993 return nativeResponseValue;
22995 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22997 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: number, val: number): void {
22998 if(!isWasmInitialized) {
22999 throw new Error("initializeWasm() must be awaited first!");
23001 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
23002 // debug statements here
23004 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23006 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: number): bigint {
23007 if(!isWasmInitialized) {
23008 throw new Error("initializeWasm() must be awaited first!");
23010 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
23011 return nativeResponseValue;
23013 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23015 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: number, val: bigint): void {
23016 if(!isWasmInitialized) {
23017 throw new Error("initializeWasm() must be awaited first!");
23019 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
23020 // debug statements here
23022 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23024 export function UnsignedChannelUpdate_get_timestamp(this_ptr: number): number {
23025 if(!isWasmInitialized) {
23026 throw new Error("initializeWasm() must be awaited first!");
23028 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
23029 return nativeResponseValue;
23031 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23033 export function UnsignedChannelUpdate_set_timestamp(this_ptr: number, val: number): void {
23034 if(!isWasmInitialized) {
23035 throw new Error("initializeWasm() must be awaited first!");
23037 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
23038 // debug statements here
23040 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23042 export function UnsignedChannelUpdate_get_flags(this_ptr: number): number {
23043 if(!isWasmInitialized) {
23044 throw new Error("initializeWasm() must be awaited first!");
23046 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
23047 return nativeResponseValue;
23049 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
23051 export function UnsignedChannelUpdate_set_flags(this_ptr: number, val: number): void {
23052 if(!isWasmInitialized) {
23053 throw new Error("initializeWasm() must be awaited first!");
23055 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
23056 // debug statements here
23058 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23060 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: number): number {
23061 if(!isWasmInitialized) {
23062 throw new Error("initializeWasm() must be awaited first!");
23064 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
23065 return nativeResponseValue;
23067 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
23069 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: number, val: number): void {
23070 if(!isWasmInitialized) {
23071 throw new Error("initializeWasm() must be awaited first!");
23073 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
23074 // debug statements here
23076 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23078 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: number): bigint {
23079 if(!isWasmInitialized) {
23080 throw new Error("initializeWasm() must be awaited first!");
23082 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
23083 return nativeResponseValue;
23085 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23087 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
23088 if(!isWasmInitialized) {
23089 throw new Error("initializeWasm() must be awaited first!");
23091 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
23092 // debug statements here
23094 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23096 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: number): number {
23097 if(!isWasmInitialized) {
23098 throw new Error("initializeWasm() must be awaited first!");
23100 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
23101 return nativeResponseValue;
23103 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23105 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: number, val: number): void {
23106 if(!isWasmInitialized) {
23107 throw new Error("initializeWasm() must be awaited first!");
23109 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
23110 // debug statements here
23112 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23114 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: number): number {
23115 if(!isWasmInitialized) {
23116 throw new Error("initializeWasm() must be awaited first!");
23118 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
23119 return nativeResponseValue;
23121 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23123 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: number, val: number): void {
23124 if(!isWasmInitialized) {
23125 throw new Error("initializeWasm() must be awaited first!");
23127 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
23128 // debug statements here
23130 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
23132 export function UnsignedChannelUpdate_set_excess_data(this_ptr: number, val: number): void {
23133 if(!isWasmInitialized) {
23134 throw new Error("initializeWasm() must be awaited first!");
23136 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
23137 // debug statements here
23139 // uintptr_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
23141 export function UnsignedChannelUpdate_clone_ptr(arg: number): number {
23142 if(!isWasmInitialized) {
23143 throw new Error("initializeWasm() must be awaited first!");
23145 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
23146 return nativeResponseValue;
23148 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
23150 export function UnsignedChannelUpdate_clone(orig: number): number {
23151 if(!isWasmInitialized) {
23152 throw new Error("initializeWasm() must be awaited first!");
23154 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
23155 return nativeResponseValue;
23157 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
23159 export function ChannelUpdate_free(this_obj: number): void {
23160 if(!isWasmInitialized) {
23161 throw new Error("initializeWasm() must be awaited first!");
23163 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
23164 // debug statements here
23166 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
23168 export function ChannelUpdate_get_signature(this_ptr: number): number {
23169 if(!isWasmInitialized) {
23170 throw new Error("initializeWasm() must be awaited first!");
23172 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
23173 return nativeResponseValue;
23175 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
23177 export function ChannelUpdate_set_signature(this_ptr: number, val: number): void {
23178 if(!isWasmInitialized) {
23179 throw new Error("initializeWasm() must be awaited first!");
23181 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
23182 // debug statements here
23184 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
23186 export function ChannelUpdate_get_contents(this_ptr: number): number {
23187 if(!isWasmInitialized) {
23188 throw new Error("initializeWasm() must be awaited first!");
23190 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
23191 return nativeResponseValue;
23193 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
23195 export function ChannelUpdate_set_contents(this_ptr: number, val: number): void {
23196 if(!isWasmInitialized) {
23197 throw new Error("initializeWasm() must be awaited first!");
23199 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
23200 // debug statements here
23202 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
23204 export function ChannelUpdate_new(signature_arg: number, contents_arg: number): number {
23205 if(!isWasmInitialized) {
23206 throw new Error("initializeWasm() must be awaited first!");
23208 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
23209 return nativeResponseValue;
23211 // uintptr_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
23213 export function ChannelUpdate_clone_ptr(arg: number): number {
23214 if(!isWasmInitialized) {
23215 throw new Error("initializeWasm() must be awaited first!");
23217 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
23218 return nativeResponseValue;
23220 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
23222 export function ChannelUpdate_clone(orig: number): number {
23223 if(!isWasmInitialized) {
23224 throw new Error("initializeWasm() must be awaited first!");
23226 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
23227 return nativeResponseValue;
23229 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
23231 export function QueryChannelRange_free(this_obj: number): void {
23232 if(!isWasmInitialized) {
23233 throw new Error("initializeWasm() must be awaited first!");
23235 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
23236 // debug statements here
23238 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
23240 export function QueryChannelRange_get_chain_hash(this_ptr: number): number {
23241 if(!isWasmInitialized) {
23242 throw new Error("initializeWasm() must be awaited first!");
23244 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
23245 return nativeResponseValue;
23247 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23249 export function QueryChannelRange_set_chain_hash(this_ptr: number, val: number): void {
23250 if(!isWasmInitialized) {
23251 throw new Error("initializeWasm() must be awaited first!");
23253 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
23254 // debug statements here
23256 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
23258 export function QueryChannelRange_get_first_blocknum(this_ptr: number): number {
23259 if(!isWasmInitialized) {
23260 throw new Error("initializeWasm() must be awaited first!");
23262 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
23263 return nativeResponseValue;
23265 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23267 export function QueryChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
23268 if(!isWasmInitialized) {
23269 throw new Error("initializeWasm() must be awaited first!");
23271 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
23272 // debug statements here
23274 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
23276 export function QueryChannelRange_get_number_of_blocks(this_ptr: number): number {
23277 if(!isWasmInitialized) {
23278 throw new Error("initializeWasm() must be awaited first!");
23280 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
23281 return nativeResponseValue;
23283 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23285 export function QueryChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
23286 if(!isWasmInitialized) {
23287 throw new Error("initializeWasm() must be awaited first!");
23289 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
23290 // debug statements here
23292 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
23294 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): number {
23295 if(!isWasmInitialized) {
23296 throw new Error("initializeWasm() must be awaited first!");
23298 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
23299 return nativeResponseValue;
23301 // uintptr_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
23303 export function QueryChannelRange_clone_ptr(arg: number): number {
23304 if(!isWasmInitialized) {
23305 throw new Error("initializeWasm() must be awaited first!");
23307 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
23308 return nativeResponseValue;
23310 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
23312 export function QueryChannelRange_clone(orig: number): number {
23313 if(!isWasmInitialized) {
23314 throw new Error("initializeWasm() must be awaited first!");
23316 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
23317 return nativeResponseValue;
23319 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
23321 export function ReplyChannelRange_free(this_obj: number): void {
23322 if(!isWasmInitialized) {
23323 throw new Error("initializeWasm() must be awaited first!");
23325 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
23326 // debug statements here
23328 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
23330 export function ReplyChannelRange_get_chain_hash(this_ptr: number): number {
23331 if(!isWasmInitialized) {
23332 throw new Error("initializeWasm() must be awaited first!");
23334 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
23335 return nativeResponseValue;
23337 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23339 export function ReplyChannelRange_set_chain_hash(this_ptr: number, val: number): void {
23340 if(!isWasmInitialized) {
23341 throw new Error("initializeWasm() must be awaited first!");
23343 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
23344 // debug statements here
23346 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
23348 export function ReplyChannelRange_get_first_blocknum(this_ptr: number): number {
23349 if(!isWasmInitialized) {
23350 throw new Error("initializeWasm() must be awaited first!");
23352 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
23353 return nativeResponseValue;
23355 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23357 export function ReplyChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
23358 if(!isWasmInitialized) {
23359 throw new Error("initializeWasm() must be awaited first!");
23361 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
23362 // debug statements here
23364 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
23366 export function ReplyChannelRange_get_number_of_blocks(this_ptr: number): number {
23367 if(!isWasmInitialized) {
23368 throw new Error("initializeWasm() must be awaited first!");
23370 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
23371 return nativeResponseValue;
23373 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23375 export function ReplyChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
23376 if(!isWasmInitialized) {
23377 throw new Error("initializeWasm() must be awaited first!");
23379 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
23380 // debug statements here
23382 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
23384 export function ReplyChannelRange_get_sync_complete(this_ptr: number): boolean {
23385 if(!isWasmInitialized) {
23386 throw new Error("initializeWasm() must be awaited first!");
23388 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
23389 return nativeResponseValue;
23391 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
23393 export function ReplyChannelRange_set_sync_complete(this_ptr: number, val: boolean): void {
23394 if(!isWasmInitialized) {
23395 throw new Error("initializeWasm() must be awaited first!");
23397 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
23398 // debug statements here
23400 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
23402 export function ReplyChannelRange_set_short_channel_ids(this_ptr: number, val: number): void {
23403 if(!isWasmInitialized) {
23404 throw new Error("initializeWasm() must be awaited first!");
23406 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
23407 // debug statements here
23409 // 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);
23411 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 {
23412 if(!isWasmInitialized) {
23413 throw new Error("initializeWasm() must be awaited first!");
23415 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
23416 return nativeResponseValue;
23418 // uintptr_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
23420 export function ReplyChannelRange_clone_ptr(arg: number): number {
23421 if(!isWasmInitialized) {
23422 throw new Error("initializeWasm() must be awaited first!");
23424 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
23425 return nativeResponseValue;
23427 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
23429 export function ReplyChannelRange_clone(orig: number): number {
23430 if(!isWasmInitialized) {
23431 throw new Error("initializeWasm() must be awaited first!");
23433 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
23434 return nativeResponseValue;
23436 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
23438 export function QueryShortChannelIds_free(this_obj: number): void {
23439 if(!isWasmInitialized) {
23440 throw new Error("initializeWasm() must be awaited first!");
23442 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
23443 // debug statements here
23445 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
23447 export function QueryShortChannelIds_get_chain_hash(this_ptr: number): number {
23448 if(!isWasmInitialized) {
23449 throw new Error("initializeWasm() must be awaited first!");
23451 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
23452 return nativeResponseValue;
23454 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23456 export function QueryShortChannelIds_set_chain_hash(this_ptr: number, val: number): void {
23457 if(!isWasmInitialized) {
23458 throw new Error("initializeWasm() must be awaited first!");
23460 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
23461 // debug statements here
23463 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
23465 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: number, val: number): void {
23466 if(!isWasmInitialized) {
23467 throw new Error("initializeWasm() must be awaited first!");
23469 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
23470 // debug statements here
23472 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
23474 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): number {
23475 if(!isWasmInitialized) {
23476 throw new Error("initializeWasm() must be awaited first!");
23478 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
23479 return nativeResponseValue;
23481 // uintptr_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
23483 export function QueryShortChannelIds_clone_ptr(arg: number): number {
23484 if(!isWasmInitialized) {
23485 throw new Error("initializeWasm() must be awaited first!");
23487 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
23488 return nativeResponseValue;
23490 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
23492 export function QueryShortChannelIds_clone(orig: number): number {
23493 if(!isWasmInitialized) {
23494 throw new Error("initializeWasm() must be awaited first!");
23496 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
23497 return nativeResponseValue;
23499 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
23501 export function ReplyShortChannelIdsEnd_free(this_obj: number): void {
23502 if(!isWasmInitialized) {
23503 throw new Error("initializeWasm() must be awaited first!");
23505 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
23506 // debug statements here
23508 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
23510 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: number): number {
23511 if(!isWasmInitialized) {
23512 throw new Error("initializeWasm() must be awaited first!");
23514 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
23515 return nativeResponseValue;
23517 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23519 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: number, val: number): void {
23520 if(!isWasmInitialized) {
23521 throw new Error("initializeWasm() must be awaited first!");
23523 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
23524 // debug statements here
23526 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
23528 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: number): boolean {
23529 if(!isWasmInitialized) {
23530 throw new Error("initializeWasm() must be awaited first!");
23532 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
23533 return nativeResponseValue;
23535 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
23537 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: number, val: boolean): void {
23538 if(!isWasmInitialized) {
23539 throw new Error("initializeWasm() must be awaited first!");
23541 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
23542 // debug statements here
23544 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
23546 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): number {
23547 if(!isWasmInitialized) {
23548 throw new Error("initializeWasm() must be awaited first!");
23550 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
23551 return nativeResponseValue;
23553 // uintptr_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
23555 export function ReplyShortChannelIdsEnd_clone_ptr(arg: number): number {
23556 if(!isWasmInitialized) {
23557 throw new Error("initializeWasm() must be awaited first!");
23559 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
23560 return nativeResponseValue;
23562 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
23564 export function ReplyShortChannelIdsEnd_clone(orig: number): number {
23565 if(!isWasmInitialized) {
23566 throw new Error("initializeWasm() must be awaited first!");
23568 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
23569 return nativeResponseValue;
23571 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
23573 export function GossipTimestampFilter_free(this_obj: number): void {
23574 if(!isWasmInitialized) {
23575 throw new Error("initializeWasm() must be awaited first!");
23577 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
23578 // debug statements here
23580 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
23582 export function GossipTimestampFilter_get_chain_hash(this_ptr: number): number {
23583 if(!isWasmInitialized) {
23584 throw new Error("initializeWasm() must be awaited first!");
23586 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
23587 return nativeResponseValue;
23589 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23591 export function GossipTimestampFilter_set_chain_hash(this_ptr: number, val: number): void {
23592 if(!isWasmInitialized) {
23593 throw new Error("initializeWasm() must be awaited first!");
23595 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
23596 // debug statements here
23598 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
23600 export function GossipTimestampFilter_get_first_timestamp(this_ptr: number): number {
23601 if(!isWasmInitialized) {
23602 throw new Error("initializeWasm() must be awaited first!");
23604 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
23605 return nativeResponseValue;
23607 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
23609 export function GossipTimestampFilter_set_first_timestamp(this_ptr: number, val: number): void {
23610 if(!isWasmInitialized) {
23611 throw new Error("initializeWasm() must be awaited first!");
23613 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
23614 // debug statements here
23616 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
23618 export function GossipTimestampFilter_get_timestamp_range(this_ptr: number): number {
23619 if(!isWasmInitialized) {
23620 throw new Error("initializeWasm() must be awaited first!");
23622 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
23623 return nativeResponseValue;
23625 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
23627 export function GossipTimestampFilter_set_timestamp_range(this_ptr: number, val: number): void {
23628 if(!isWasmInitialized) {
23629 throw new Error("initializeWasm() must be awaited first!");
23631 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
23632 // debug statements here
23634 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
23636 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): number {
23637 if(!isWasmInitialized) {
23638 throw new Error("initializeWasm() must be awaited first!");
23640 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
23641 return nativeResponseValue;
23643 // uintptr_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
23645 export function GossipTimestampFilter_clone_ptr(arg: number): number {
23646 if(!isWasmInitialized) {
23647 throw new Error("initializeWasm() must be awaited first!");
23649 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
23650 return nativeResponseValue;
23652 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
23654 export function GossipTimestampFilter_clone(orig: number): number {
23655 if(!isWasmInitialized) {
23656 throw new Error("initializeWasm() must be awaited first!");
23658 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
23659 return nativeResponseValue;
23661 // void ErrorAction_free(struct LDKErrorAction this_ptr);
23663 export function ErrorAction_free(this_ptr: number): void {
23664 if(!isWasmInitialized) {
23665 throw new Error("initializeWasm() must be awaited first!");
23667 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
23668 // debug statements here
23670 // uintptr_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
23672 export function ErrorAction_clone_ptr(arg: number): number {
23673 if(!isWasmInitialized) {
23674 throw new Error("initializeWasm() must be awaited first!");
23676 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
23677 return nativeResponseValue;
23679 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
23681 export function ErrorAction_clone(orig: number): number {
23682 if(!isWasmInitialized) {
23683 throw new Error("initializeWasm() must be awaited first!");
23685 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
23686 return nativeResponseValue;
23688 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
23690 export function ErrorAction_disconnect_peer(msg: number): number {
23691 if(!isWasmInitialized) {
23692 throw new Error("initializeWasm() must be awaited first!");
23694 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
23695 return nativeResponseValue;
23697 // struct LDKErrorAction ErrorAction_ignore_error(void);
23699 export function ErrorAction_ignore_error(): number {
23700 if(!isWasmInitialized) {
23701 throw new Error("initializeWasm() must be awaited first!");
23703 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
23704 return nativeResponseValue;
23706 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
23708 export function ErrorAction_ignore_and_log(a: Level): number {
23709 if(!isWasmInitialized) {
23710 throw new Error("initializeWasm() must be awaited first!");
23712 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
23713 return nativeResponseValue;
23715 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
23717 export function ErrorAction_ignore_duplicate_gossip(): number {
23718 if(!isWasmInitialized) {
23719 throw new Error("initializeWasm() must be awaited first!");
23721 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
23722 return nativeResponseValue;
23724 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
23726 export function ErrorAction_send_error_message(msg: number): number {
23727 if(!isWasmInitialized) {
23728 throw new Error("initializeWasm() must be awaited first!");
23730 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
23731 return nativeResponseValue;
23733 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
23735 export function ErrorAction_send_warning_message(msg: number, log_level: Level): number {
23736 if(!isWasmInitialized) {
23737 throw new Error("initializeWasm() must be awaited first!");
23739 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
23740 return nativeResponseValue;
23742 // void LightningError_free(struct LDKLightningError this_obj);
23744 export function LightningError_free(this_obj: number): void {
23745 if(!isWasmInitialized) {
23746 throw new Error("initializeWasm() must be awaited first!");
23748 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
23749 // debug statements here
23751 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
23753 export function LightningError_get_err(this_ptr: number): number {
23754 if(!isWasmInitialized) {
23755 throw new Error("initializeWasm() must be awaited first!");
23757 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
23758 return nativeResponseValue;
23760 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
23762 export function LightningError_set_err(this_ptr: number, val: number): void {
23763 if(!isWasmInitialized) {
23764 throw new Error("initializeWasm() must be awaited first!");
23766 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
23767 // debug statements here
23769 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
23771 export function LightningError_get_action(this_ptr: number): number {
23772 if(!isWasmInitialized) {
23773 throw new Error("initializeWasm() must be awaited first!");
23775 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
23776 return nativeResponseValue;
23778 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
23780 export function LightningError_set_action(this_ptr: number, val: number): void {
23781 if(!isWasmInitialized) {
23782 throw new Error("initializeWasm() must be awaited first!");
23784 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
23785 // debug statements here
23787 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
23789 export function LightningError_new(err_arg: number, action_arg: number): number {
23790 if(!isWasmInitialized) {
23791 throw new Error("initializeWasm() must be awaited first!");
23793 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
23794 return nativeResponseValue;
23796 // uintptr_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
23798 export function LightningError_clone_ptr(arg: number): number {
23799 if(!isWasmInitialized) {
23800 throw new Error("initializeWasm() must be awaited first!");
23802 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
23803 return nativeResponseValue;
23805 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
23807 export function LightningError_clone(orig: number): number {
23808 if(!isWasmInitialized) {
23809 throw new Error("initializeWasm() must be awaited first!");
23811 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
23812 return nativeResponseValue;
23814 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
23816 export function CommitmentUpdate_free(this_obj: number): void {
23817 if(!isWasmInitialized) {
23818 throw new Error("initializeWasm() must be awaited first!");
23820 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
23821 // debug statements here
23823 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23825 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: number): number {
23826 if(!isWasmInitialized) {
23827 throw new Error("initializeWasm() must be awaited first!");
23829 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
23830 return nativeResponseValue;
23832 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
23834 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: number, val: number): void {
23835 if(!isWasmInitialized) {
23836 throw new Error("initializeWasm() must be awaited first!");
23838 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
23839 // debug statements here
23841 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23843 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: number): number {
23844 if(!isWasmInitialized) {
23845 throw new Error("initializeWasm() must be awaited first!");
23847 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
23848 return nativeResponseValue;
23850 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
23852 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: number, val: number): void {
23853 if(!isWasmInitialized) {
23854 throw new Error("initializeWasm() must be awaited first!");
23856 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
23857 // debug statements here
23859 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23861 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: number): number {
23862 if(!isWasmInitialized) {
23863 throw new Error("initializeWasm() must be awaited first!");
23865 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
23866 return nativeResponseValue;
23868 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
23870 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: number, val: number): void {
23871 if(!isWasmInitialized) {
23872 throw new Error("initializeWasm() must be awaited first!");
23874 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
23875 // debug statements here
23877 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23879 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: number): number {
23880 if(!isWasmInitialized) {
23881 throw new Error("initializeWasm() must be awaited first!");
23883 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
23884 return nativeResponseValue;
23886 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
23888 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: number, val: number): void {
23889 if(!isWasmInitialized) {
23890 throw new Error("initializeWasm() must be awaited first!");
23892 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
23893 // debug statements here
23895 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23897 export function CommitmentUpdate_get_update_fee(this_ptr: number): number {
23898 if(!isWasmInitialized) {
23899 throw new Error("initializeWasm() must be awaited first!");
23901 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
23902 return nativeResponseValue;
23904 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
23906 export function CommitmentUpdate_set_update_fee(this_ptr: number, val: number): void {
23907 if(!isWasmInitialized) {
23908 throw new Error("initializeWasm() must be awaited first!");
23910 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
23911 // debug statements here
23913 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
23915 export function CommitmentUpdate_get_commitment_signed(this_ptr: number): number {
23916 if(!isWasmInitialized) {
23917 throw new Error("initializeWasm() must be awaited first!");
23919 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
23920 return nativeResponseValue;
23922 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
23924 export function CommitmentUpdate_set_commitment_signed(this_ptr: number, val: number): void {
23925 if(!isWasmInitialized) {
23926 throw new Error("initializeWasm() must be awaited first!");
23928 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
23929 // debug statements here
23931 // 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);
23933 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 {
23934 if(!isWasmInitialized) {
23935 throw new Error("initializeWasm() must be awaited first!");
23937 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);
23938 return nativeResponseValue;
23940 // uintptr_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
23942 export function CommitmentUpdate_clone_ptr(arg: number): number {
23943 if(!isWasmInitialized) {
23944 throw new Error("initializeWasm() must be awaited first!");
23946 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
23947 return nativeResponseValue;
23949 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
23951 export function CommitmentUpdate_clone(orig: number): number {
23952 if(!isWasmInitialized) {
23953 throw new Error("initializeWasm() must be awaited first!");
23955 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
23956 return nativeResponseValue;
23958 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
23960 export function ChannelMessageHandler_free(this_ptr: number): void {
23961 if(!isWasmInitialized) {
23962 throw new Error("initializeWasm() must be awaited first!");
23964 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
23965 // debug statements here
23967 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
23969 export function RoutingMessageHandler_free(this_ptr: number): void {
23970 if(!isWasmInitialized) {
23971 throw new Error("initializeWasm() must be awaited first!");
23973 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
23974 // debug statements here
23976 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
23978 export function AcceptChannel_write(obj: number): number {
23979 if(!isWasmInitialized) {
23980 throw new Error("initializeWasm() must be awaited first!");
23982 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
23983 return nativeResponseValue;
23985 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
23987 export function AcceptChannel_read(ser: number): number {
23988 if(!isWasmInitialized) {
23989 throw new Error("initializeWasm() must be awaited first!");
23991 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
23992 return nativeResponseValue;
23994 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
23996 export function AnnouncementSignatures_write(obj: number): number {
23997 if(!isWasmInitialized) {
23998 throw new Error("initializeWasm() must be awaited first!");
24000 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
24001 return nativeResponseValue;
24003 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
24005 export function AnnouncementSignatures_read(ser: number): number {
24006 if(!isWasmInitialized) {
24007 throw new Error("initializeWasm() must be awaited first!");
24009 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
24010 return nativeResponseValue;
24012 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
24014 export function ChannelReestablish_write(obj: number): number {
24015 if(!isWasmInitialized) {
24016 throw new Error("initializeWasm() must be awaited first!");
24018 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
24019 return nativeResponseValue;
24021 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
24023 export function ChannelReestablish_read(ser: number): number {
24024 if(!isWasmInitialized) {
24025 throw new Error("initializeWasm() must be awaited first!");
24027 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
24028 return nativeResponseValue;
24030 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
24032 export function ClosingSigned_write(obj: number): number {
24033 if(!isWasmInitialized) {
24034 throw new Error("initializeWasm() must be awaited first!");
24036 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
24037 return nativeResponseValue;
24039 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
24041 export function ClosingSigned_read(ser: number): number {
24042 if(!isWasmInitialized) {
24043 throw new Error("initializeWasm() must be awaited first!");
24045 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
24046 return nativeResponseValue;
24048 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
24050 export function ClosingSignedFeeRange_write(obj: number): number {
24051 if(!isWasmInitialized) {
24052 throw new Error("initializeWasm() must be awaited first!");
24054 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
24055 return nativeResponseValue;
24057 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
24059 export function ClosingSignedFeeRange_read(ser: number): number {
24060 if(!isWasmInitialized) {
24061 throw new Error("initializeWasm() must be awaited first!");
24063 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
24064 return nativeResponseValue;
24066 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
24068 export function CommitmentSigned_write(obj: number): number {
24069 if(!isWasmInitialized) {
24070 throw new Error("initializeWasm() must be awaited first!");
24072 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
24073 return nativeResponseValue;
24075 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
24077 export function CommitmentSigned_read(ser: number): number {
24078 if(!isWasmInitialized) {
24079 throw new Error("initializeWasm() must be awaited first!");
24081 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
24082 return nativeResponseValue;
24084 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
24086 export function FundingCreated_write(obj: number): number {
24087 if(!isWasmInitialized) {
24088 throw new Error("initializeWasm() must be awaited first!");
24090 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
24091 return nativeResponseValue;
24093 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
24095 export function FundingCreated_read(ser: number): number {
24096 if(!isWasmInitialized) {
24097 throw new Error("initializeWasm() must be awaited first!");
24099 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
24100 return nativeResponseValue;
24102 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
24104 export function FundingSigned_write(obj: number): number {
24105 if(!isWasmInitialized) {
24106 throw new Error("initializeWasm() must be awaited first!");
24108 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
24109 return nativeResponseValue;
24111 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
24113 export function FundingSigned_read(ser: number): number {
24114 if(!isWasmInitialized) {
24115 throw new Error("initializeWasm() must be awaited first!");
24117 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
24118 return nativeResponseValue;
24120 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
24122 export function ChannelReady_write(obj: number): number {
24123 if(!isWasmInitialized) {
24124 throw new Error("initializeWasm() must be awaited first!");
24126 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
24127 return nativeResponseValue;
24129 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
24131 export function ChannelReady_read(ser: number): number {
24132 if(!isWasmInitialized) {
24133 throw new Error("initializeWasm() must be awaited first!");
24135 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
24136 return nativeResponseValue;
24138 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
24140 export function Init_write(obj: number): number {
24141 if(!isWasmInitialized) {
24142 throw new Error("initializeWasm() must be awaited first!");
24144 const nativeResponseValue = wasm.TS_Init_write(obj);
24145 return nativeResponseValue;
24147 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
24149 export function Init_read(ser: number): number {
24150 if(!isWasmInitialized) {
24151 throw new Error("initializeWasm() must be awaited first!");
24153 const nativeResponseValue = wasm.TS_Init_read(ser);
24154 return nativeResponseValue;
24156 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
24158 export function OpenChannel_write(obj: number): number {
24159 if(!isWasmInitialized) {
24160 throw new Error("initializeWasm() must be awaited first!");
24162 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
24163 return nativeResponseValue;
24165 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
24167 export function OpenChannel_read(ser: number): number {
24168 if(!isWasmInitialized) {
24169 throw new Error("initializeWasm() must be awaited first!");
24171 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
24172 return nativeResponseValue;
24174 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
24176 export function RevokeAndACK_write(obj: number): number {
24177 if(!isWasmInitialized) {
24178 throw new Error("initializeWasm() must be awaited first!");
24180 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
24181 return nativeResponseValue;
24183 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
24185 export function RevokeAndACK_read(ser: number): number {
24186 if(!isWasmInitialized) {
24187 throw new Error("initializeWasm() must be awaited first!");
24189 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
24190 return nativeResponseValue;
24192 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
24194 export function Shutdown_write(obj: number): number {
24195 if(!isWasmInitialized) {
24196 throw new Error("initializeWasm() must be awaited first!");
24198 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
24199 return nativeResponseValue;
24201 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
24203 export function Shutdown_read(ser: number): number {
24204 if(!isWasmInitialized) {
24205 throw new Error("initializeWasm() must be awaited first!");
24207 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
24208 return nativeResponseValue;
24210 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
24212 export function UpdateFailHTLC_write(obj: number): number {
24213 if(!isWasmInitialized) {
24214 throw new Error("initializeWasm() must be awaited first!");
24216 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
24217 return nativeResponseValue;
24219 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
24221 export function UpdateFailHTLC_read(ser: number): number {
24222 if(!isWasmInitialized) {
24223 throw new Error("initializeWasm() must be awaited first!");
24225 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
24226 return nativeResponseValue;
24228 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
24230 export function UpdateFailMalformedHTLC_write(obj: number): number {
24231 if(!isWasmInitialized) {
24232 throw new Error("initializeWasm() must be awaited first!");
24234 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
24235 return nativeResponseValue;
24237 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
24239 export function UpdateFailMalformedHTLC_read(ser: number): number {
24240 if(!isWasmInitialized) {
24241 throw new Error("initializeWasm() must be awaited first!");
24243 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
24244 return nativeResponseValue;
24246 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
24248 export function UpdateFee_write(obj: number): number {
24249 if(!isWasmInitialized) {
24250 throw new Error("initializeWasm() must be awaited first!");
24252 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
24253 return nativeResponseValue;
24255 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
24257 export function UpdateFee_read(ser: number): number {
24258 if(!isWasmInitialized) {
24259 throw new Error("initializeWasm() must be awaited first!");
24261 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
24262 return nativeResponseValue;
24264 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
24266 export function UpdateFulfillHTLC_write(obj: number): number {
24267 if(!isWasmInitialized) {
24268 throw new Error("initializeWasm() must be awaited first!");
24270 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
24271 return nativeResponseValue;
24273 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
24275 export function UpdateFulfillHTLC_read(ser: number): number {
24276 if(!isWasmInitialized) {
24277 throw new Error("initializeWasm() must be awaited first!");
24279 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
24280 return nativeResponseValue;
24282 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
24284 export function UpdateAddHTLC_write(obj: number): number {
24285 if(!isWasmInitialized) {
24286 throw new Error("initializeWasm() must be awaited first!");
24288 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
24289 return nativeResponseValue;
24291 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
24293 export function UpdateAddHTLC_read(ser: number): number {
24294 if(!isWasmInitialized) {
24295 throw new Error("initializeWasm() must be awaited first!");
24297 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
24298 return nativeResponseValue;
24300 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
24302 export function Ping_write(obj: number): number {
24303 if(!isWasmInitialized) {
24304 throw new Error("initializeWasm() must be awaited first!");
24306 const nativeResponseValue = wasm.TS_Ping_write(obj);
24307 return nativeResponseValue;
24309 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
24311 export function Ping_read(ser: number): number {
24312 if(!isWasmInitialized) {
24313 throw new Error("initializeWasm() must be awaited first!");
24315 const nativeResponseValue = wasm.TS_Ping_read(ser);
24316 return nativeResponseValue;
24318 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
24320 export function Pong_write(obj: number): number {
24321 if(!isWasmInitialized) {
24322 throw new Error("initializeWasm() must be awaited first!");
24324 const nativeResponseValue = wasm.TS_Pong_write(obj);
24325 return nativeResponseValue;
24327 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
24329 export function Pong_read(ser: number): number {
24330 if(!isWasmInitialized) {
24331 throw new Error("initializeWasm() must be awaited first!");
24333 const nativeResponseValue = wasm.TS_Pong_read(ser);
24334 return nativeResponseValue;
24336 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
24338 export function UnsignedChannelAnnouncement_write(obj: number): number {
24339 if(!isWasmInitialized) {
24340 throw new Error("initializeWasm() must be awaited first!");
24342 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
24343 return nativeResponseValue;
24345 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
24347 export function UnsignedChannelAnnouncement_read(ser: number): number {
24348 if(!isWasmInitialized) {
24349 throw new Error("initializeWasm() must be awaited first!");
24351 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
24352 return nativeResponseValue;
24354 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
24356 export function ChannelAnnouncement_write(obj: number): number {
24357 if(!isWasmInitialized) {
24358 throw new Error("initializeWasm() must be awaited first!");
24360 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
24361 return nativeResponseValue;
24363 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
24365 export function ChannelAnnouncement_read(ser: number): number {
24366 if(!isWasmInitialized) {
24367 throw new Error("initializeWasm() must be awaited first!");
24369 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
24370 return nativeResponseValue;
24372 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
24374 export function UnsignedChannelUpdate_write(obj: number): number {
24375 if(!isWasmInitialized) {
24376 throw new Error("initializeWasm() must be awaited first!");
24378 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
24379 return nativeResponseValue;
24381 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
24383 export function UnsignedChannelUpdate_read(ser: number): number {
24384 if(!isWasmInitialized) {
24385 throw new Error("initializeWasm() must be awaited first!");
24387 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
24388 return nativeResponseValue;
24390 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
24392 export function ChannelUpdate_write(obj: number): number {
24393 if(!isWasmInitialized) {
24394 throw new Error("initializeWasm() must be awaited first!");
24396 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
24397 return nativeResponseValue;
24399 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
24401 export function ChannelUpdate_read(ser: number): number {
24402 if(!isWasmInitialized) {
24403 throw new Error("initializeWasm() must be awaited first!");
24405 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
24406 return nativeResponseValue;
24408 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
24410 export function ErrorMessage_write(obj: number): number {
24411 if(!isWasmInitialized) {
24412 throw new Error("initializeWasm() must be awaited first!");
24414 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
24415 return nativeResponseValue;
24417 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
24419 export function ErrorMessage_read(ser: number): number {
24420 if(!isWasmInitialized) {
24421 throw new Error("initializeWasm() must be awaited first!");
24423 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
24424 return nativeResponseValue;
24426 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
24428 export function WarningMessage_write(obj: number): number {
24429 if(!isWasmInitialized) {
24430 throw new Error("initializeWasm() must be awaited first!");
24432 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
24433 return nativeResponseValue;
24435 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
24437 export function WarningMessage_read(ser: number): number {
24438 if(!isWasmInitialized) {
24439 throw new Error("initializeWasm() must be awaited first!");
24441 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
24442 return nativeResponseValue;
24444 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
24446 export function UnsignedNodeAnnouncement_write(obj: number): number {
24447 if(!isWasmInitialized) {
24448 throw new Error("initializeWasm() must be awaited first!");
24450 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
24451 return nativeResponseValue;
24453 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
24455 export function UnsignedNodeAnnouncement_read(ser: number): number {
24456 if(!isWasmInitialized) {
24457 throw new Error("initializeWasm() must be awaited first!");
24459 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
24460 return nativeResponseValue;
24462 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
24464 export function NodeAnnouncement_write(obj: number): number {
24465 if(!isWasmInitialized) {
24466 throw new Error("initializeWasm() must be awaited first!");
24468 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
24469 return nativeResponseValue;
24471 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
24473 export function NodeAnnouncement_read(ser: number): number {
24474 if(!isWasmInitialized) {
24475 throw new Error("initializeWasm() must be awaited first!");
24477 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
24478 return nativeResponseValue;
24480 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
24482 export function QueryShortChannelIds_read(ser: number): number {
24483 if(!isWasmInitialized) {
24484 throw new Error("initializeWasm() must be awaited first!");
24486 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
24487 return nativeResponseValue;
24489 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
24491 export function QueryShortChannelIds_write(obj: number): number {
24492 if(!isWasmInitialized) {
24493 throw new Error("initializeWasm() must be awaited first!");
24495 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
24496 return nativeResponseValue;
24498 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
24500 export function ReplyShortChannelIdsEnd_write(obj: number): number {
24501 if(!isWasmInitialized) {
24502 throw new Error("initializeWasm() must be awaited first!");
24504 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
24505 return nativeResponseValue;
24507 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
24509 export function ReplyShortChannelIdsEnd_read(ser: number): number {
24510 if(!isWasmInitialized) {
24511 throw new Error("initializeWasm() must be awaited first!");
24513 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
24514 return nativeResponseValue;
24516 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
24518 export function QueryChannelRange_end_blocknum(this_arg: number): number {
24519 if(!isWasmInitialized) {
24520 throw new Error("initializeWasm() must be awaited first!");
24522 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
24523 return nativeResponseValue;
24525 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
24527 export function QueryChannelRange_write(obj: number): number {
24528 if(!isWasmInitialized) {
24529 throw new Error("initializeWasm() must be awaited first!");
24531 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
24532 return nativeResponseValue;
24534 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
24536 export function QueryChannelRange_read(ser: number): number {
24537 if(!isWasmInitialized) {
24538 throw new Error("initializeWasm() must be awaited first!");
24540 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
24541 return nativeResponseValue;
24543 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
24545 export function ReplyChannelRange_read(ser: number): number {
24546 if(!isWasmInitialized) {
24547 throw new Error("initializeWasm() must be awaited first!");
24549 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
24550 return nativeResponseValue;
24552 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
24554 export function ReplyChannelRange_write(obj: number): number {
24555 if(!isWasmInitialized) {
24556 throw new Error("initializeWasm() must be awaited first!");
24558 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
24559 return nativeResponseValue;
24561 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
24563 export function GossipTimestampFilter_write(obj: number): number {
24564 if(!isWasmInitialized) {
24565 throw new Error("initializeWasm() must be awaited first!");
24567 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
24568 return nativeResponseValue;
24570 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
24572 export function GossipTimestampFilter_read(ser: number): number {
24573 if(!isWasmInitialized) {
24574 throw new Error("initializeWasm() must be awaited first!");
24576 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
24577 return nativeResponseValue;
24579 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
24581 export function CustomMessageHandler_free(this_ptr: number): void {
24582 if(!isWasmInitialized) {
24583 throw new Error("initializeWasm() must be awaited first!");
24585 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
24586 // debug statements here
24588 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
24590 export function IgnoringMessageHandler_free(this_obj: number): void {
24591 if(!isWasmInitialized) {
24592 throw new Error("initializeWasm() must be awaited first!");
24594 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
24595 // debug statements here
24597 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
24599 export function IgnoringMessageHandler_new(): number {
24600 if(!isWasmInitialized) {
24601 throw new Error("initializeWasm() must be awaited first!");
24603 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
24604 return nativeResponseValue;
24606 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24608 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
24609 if(!isWasmInitialized) {
24610 throw new Error("initializeWasm() must be awaited first!");
24612 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
24613 return nativeResponseValue;
24615 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24617 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
24618 if(!isWasmInitialized) {
24619 throw new Error("initializeWasm() must be awaited first!");
24621 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
24622 return nativeResponseValue;
24624 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24626 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: number): number {
24627 if(!isWasmInitialized) {
24628 throw new Error("initializeWasm() must be awaited first!");
24630 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
24631 return nativeResponseValue;
24633 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24635 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: number): number {
24636 if(!isWasmInitialized) {
24637 throw new Error("initializeWasm() must be awaited first!");
24639 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
24640 return nativeResponseValue;
24642 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
24644 export function ErroringMessageHandler_free(this_obj: number): void {
24645 if(!isWasmInitialized) {
24646 throw new Error("initializeWasm() must be awaited first!");
24648 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
24649 // debug statements here
24651 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
24653 export function ErroringMessageHandler_new(): number {
24654 if(!isWasmInitialized) {
24655 throw new Error("initializeWasm() must be awaited first!");
24657 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
24658 return nativeResponseValue;
24660 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
24662 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
24663 if(!isWasmInitialized) {
24664 throw new Error("initializeWasm() must be awaited first!");
24666 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
24667 return nativeResponseValue;
24669 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
24671 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
24672 if(!isWasmInitialized) {
24673 throw new Error("initializeWasm() must be awaited first!");
24675 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
24676 return nativeResponseValue;
24678 // void MessageHandler_free(struct LDKMessageHandler this_obj);
24680 export function MessageHandler_free(this_obj: number): void {
24681 if(!isWasmInitialized) {
24682 throw new Error("initializeWasm() must be awaited first!");
24684 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
24685 // debug statements here
24687 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
24689 export function MessageHandler_get_chan_handler(this_ptr: number): number {
24690 if(!isWasmInitialized) {
24691 throw new Error("initializeWasm() must be awaited first!");
24693 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
24694 return nativeResponseValue;
24696 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
24698 export function MessageHandler_set_chan_handler(this_ptr: number, val: number): void {
24699 if(!isWasmInitialized) {
24700 throw new Error("initializeWasm() must be awaited first!");
24702 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
24703 // debug statements here
24705 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
24707 export function MessageHandler_get_route_handler(this_ptr: number): number {
24708 if(!isWasmInitialized) {
24709 throw new Error("initializeWasm() must be awaited first!");
24711 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
24712 return nativeResponseValue;
24714 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
24716 export function MessageHandler_set_route_handler(this_ptr: number, val: number): void {
24717 if(!isWasmInitialized) {
24718 throw new Error("initializeWasm() must be awaited first!");
24720 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
24721 // debug statements here
24723 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
24725 export function MessageHandler_new(chan_handler_arg: number, route_handler_arg: number): number {
24726 if(!isWasmInitialized) {
24727 throw new Error("initializeWasm() must be awaited first!");
24729 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg);
24730 return nativeResponseValue;
24732 // uintptr_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
24734 export function SocketDescriptor_clone_ptr(arg: number): number {
24735 if(!isWasmInitialized) {
24736 throw new Error("initializeWasm() must be awaited first!");
24738 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
24739 return nativeResponseValue;
24741 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
24743 export function SocketDescriptor_clone(orig: number): number {
24744 if(!isWasmInitialized) {
24745 throw new Error("initializeWasm() must be awaited first!");
24747 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
24748 return nativeResponseValue;
24750 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
24752 export function SocketDescriptor_free(this_ptr: number): void {
24753 if(!isWasmInitialized) {
24754 throw new Error("initializeWasm() must be awaited first!");
24756 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
24757 // debug statements here
24759 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
24761 export function PeerHandleError_free(this_obj: number): void {
24762 if(!isWasmInitialized) {
24763 throw new Error("initializeWasm() must be awaited first!");
24765 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
24766 // debug statements here
24768 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
24770 export function PeerHandleError_get_no_connection_possible(this_ptr: number): boolean {
24771 if(!isWasmInitialized) {
24772 throw new Error("initializeWasm() must be awaited first!");
24774 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
24775 return nativeResponseValue;
24777 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
24779 export function PeerHandleError_set_no_connection_possible(this_ptr: number, val: boolean): void {
24780 if(!isWasmInitialized) {
24781 throw new Error("initializeWasm() must be awaited first!");
24783 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
24784 // debug statements here
24786 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
24788 export function PeerHandleError_new(no_connection_possible_arg: boolean): number {
24789 if(!isWasmInitialized) {
24790 throw new Error("initializeWasm() must be awaited first!");
24792 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
24793 return nativeResponseValue;
24795 // uintptr_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
24797 export function PeerHandleError_clone_ptr(arg: number): number {
24798 if(!isWasmInitialized) {
24799 throw new Error("initializeWasm() must be awaited first!");
24801 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
24802 return nativeResponseValue;
24804 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
24806 export function PeerHandleError_clone(orig: number): number {
24807 if(!isWasmInitialized) {
24808 throw new Error("initializeWasm() must be awaited first!");
24810 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
24811 return nativeResponseValue;
24813 // void PeerManager_free(struct LDKPeerManager this_obj);
24815 export function PeerManager_free(this_obj: number): void {
24816 if(!isWasmInitialized) {
24817 throw new Error("initializeWasm() must be awaited first!");
24819 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
24820 // debug statements here
24822 // 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);
24824 export function PeerManager_new(message_handler: number, our_node_secret: number, ephemeral_random_data: number, logger: number, custom_message_handler: number): number {
24825 if(!isWasmInitialized) {
24826 throw new Error("initializeWasm() must be awaited first!");
24828 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, ephemeral_random_data, logger, custom_message_handler);
24829 return nativeResponseValue;
24831 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
24833 export function PeerManager_get_peer_node_ids(this_arg: number): number {
24834 if(!isWasmInitialized) {
24835 throw new Error("initializeWasm() must be awaited first!");
24837 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
24838 return nativeResponseValue;
24840 // 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);
24842 export function PeerManager_new_outbound_connection(this_arg: number, their_node_id: number, descriptor: number, remote_network_address: number): number {
24843 if(!isWasmInitialized) {
24844 throw new Error("initializeWasm() must be awaited first!");
24846 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
24847 return nativeResponseValue;
24849 // 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);
24851 export function PeerManager_new_inbound_connection(this_arg: number, descriptor: number, remote_network_address: number): number {
24852 if(!isWasmInitialized) {
24853 throw new Error("initializeWasm() must be awaited first!");
24855 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
24856 return nativeResponseValue;
24858 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
24860 export function PeerManager_write_buffer_space_avail(this_arg: number, descriptor: number): number {
24861 if(!isWasmInitialized) {
24862 throw new Error("initializeWasm() must be awaited first!");
24864 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
24865 return nativeResponseValue;
24867 // 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);
24869 export function PeerManager_read_event(this_arg: number, peer_descriptor: number, data: number): number {
24870 if(!isWasmInitialized) {
24871 throw new Error("initializeWasm() must be awaited first!");
24873 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
24874 return nativeResponseValue;
24876 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
24878 export function PeerManager_process_events(this_arg: number): void {
24879 if(!isWasmInitialized) {
24880 throw new Error("initializeWasm() must be awaited first!");
24882 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
24883 // debug statements here
24885 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
24887 export function PeerManager_socket_disconnected(this_arg: number, descriptor: number): void {
24888 if(!isWasmInitialized) {
24889 throw new Error("initializeWasm() must be awaited first!");
24891 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
24892 // debug statements here
24894 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
24896 export function PeerManager_disconnect_by_node_id(this_arg: number, node_id: number, no_connection_possible: boolean): void {
24897 if(!isWasmInitialized) {
24898 throw new Error("initializeWasm() must be awaited first!");
24900 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
24901 // debug statements here
24903 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
24905 export function PeerManager_disconnect_all_peers(this_arg: number): void {
24906 if(!isWasmInitialized) {
24907 throw new Error("initializeWasm() must be awaited first!");
24909 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
24910 // debug statements here
24912 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
24914 export function PeerManager_timer_tick_occurred(this_arg: number): void {
24915 if(!isWasmInitialized) {
24916 throw new Error("initializeWasm() must be awaited first!");
24918 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
24919 // debug statements here
24921 // uint64_t htlc_success_tx_weight(bool opt_anchors);
24923 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
24924 if(!isWasmInitialized) {
24925 throw new Error("initializeWasm() must be awaited first!");
24927 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
24928 return nativeResponseValue;
24930 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
24932 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
24933 if(!isWasmInitialized) {
24934 throw new Error("initializeWasm() must be awaited first!");
24936 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
24937 return nativeResponseValue;
24939 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
24941 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
24942 if(!isWasmInitialized) {
24943 throw new Error("initializeWasm() must be awaited first!");
24945 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
24946 return nativeResponseValue;
24948 // 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);
24950 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 {
24951 if(!isWasmInitialized) {
24952 throw new Error("initializeWasm() must be awaited first!");
24954 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
24955 return nativeResponseValue;
24957 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
24959 export function CounterpartyCommitmentSecrets_free(this_obj: number): void {
24960 if(!isWasmInitialized) {
24961 throw new Error("initializeWasm() must be awaited first!");
24963 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
24964 // debug statements here
24966 // uintptr_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
24968 export function CounterpartyCommitmentSecrets_clone_ptr(arg: number): number {
24969 if(!isWasmInitialized) {
24970 throw new Error("initializeWasm() must be awaited first!");
24972 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
24973 return nativeResponseValue;
24975 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
24977 export function CounterpartyCommitmentSecrets_clone(orig: number): number {
24978 if(!isWasmInitialized) {
24979 throw new Error("initializeWasm() must be awaited first!");
24981 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
24982 return nativeResponseValue;
24984 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
24986 export function CounterpartyCommitmentSecrets_new(): number {
24987 if(!isWasmInitialized) {
24988 throw new Error("initializeWasm() must be awaited first!");
24990 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
24991 return nativeResponseValue;
24993 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
24995 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: number): bigint {
24996 if(!isWasmInitialized) {
24997 throw new Error("initializeWasm() must be awaited first!");
24999 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
25000 return nativeResponseValue;
25002 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
25004 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: number, idx: bigint, secret: number): number {
25005 if(!isWasmInitialized) {
25006 throw new Error("initializeWasm() must be awaited first!");
25008 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
25009 return nativeResponseValue;
25011 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
25013 export function CounterpartyCommitmentSecrets_get_secret(this_arg: number, idx: bigint): number {
25014 if(!isWasmInitialized) {
25015 throw new Error("initializeWasm() must be awaited first!");
25017 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
25018 return nativeResponseValue;
25020 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
25022 export function CounterpartyCommitmentSecrets_write(obj: number): number {
25023 if(!isWasmInitialized) {
25024 throw new Error("initializeWasm() must be awaited first!");
25026 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
25027 return nativeResponseValue;
25029 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
25031 export function CounterpartyCommitmentSecrets_read(ser: number): number {
25032 if(!isWasmInitialized) {
25033 throw new Error("initializeWasm() must be awaited first!");
25035 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
25036 return nativeResponseValue;
25038 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
25040 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
25041 if(!isWasmInitialized) {
25042 throw new Error("initializeWasm() must be awaited first!");
25044 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
25045 return nativeResponseValue;
25047 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
25049 export function derive_public_key(per_commitment_point: number, base_point: number): number {
25050 if(!isWasmInitialized) {
25051 throw new Error("initializeWasm() must be awaited first!");
25053 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
25054 return nativeResponseValue;
25056 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
25058 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
25059 if(!isWasmInitialized) {
25060 throw new Error("initializeWasm() must be awaited first!");
25062 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
25063 return nativeResponseValue;
25065 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
25067 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
25068 if(!isWasmInitialized) {
25069 throw new Error("initializeWasm() must be awaited first!");
25071 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
25072 return nativeResponseValue;
25074 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
25076 export function TxCreationKeys_free(this_obj: number): void {
25077 if(!isWasmInitialized) {
25078 throw new Error("initializeWasm() must be awaited first!");
25080 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
25081 // debug statements here
25083 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25085 export function TxCreationKeys_get_per_commitment_point(this_ptr: number): number {
25086 if(!isWasmInitialized) {
25087 throw new Error("initializeWasm() must be awaited first!");
25089 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
25090 return nativeResponseValue;
25092 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25094 export function TxCreationKeys_set_per_commitment_point(this_ptr: number, val: number): void {
25095 if(!isWasmInitialized) {
25096 throw new Error("initializeWasm() must be awaited first!");
25098 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
25099 // debug statements here
25101 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25103 export function TxCreationKeys_get_revocation_key(this_ptr: number): number {
25104 if(!isWasmInitialized) {
25105 throw new Error("initializeWasm() must be awaited first!");
25107 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
25108 return nativeResponseValue;
25110 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25112 export function TxCreationKeys_set_revocation_key(this_ptr: number, val: number): void {
25113 if(!isWasmInitialized) {
25114 throw new Error("initializeWasm() must be awaited first!");
25116 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
25117 // debug statements here
25119 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25121 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: number): number {
25122 if(!isWasmInitialized) {
25123 throw new Error("initializeWasm() must be awaited first!");
25125 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
25126 return nativeResponseValue;
25128 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25130 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: number, val: number): void {
25131 if(!isWasmInitialized) {
25132 throw new Error("initializeWasm() must be awaited first!");
25134 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
25135 // debug statements here
25137 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25139 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: number): number {
25140 if(!isWasmInitialized) {
25141 throw new Error("initializeWasm() must be awaited first!");
25143 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
25144 return nativeResponseValue;
25146 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25148 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: number, val: number): void {
25149 if(!isWasmInitialized) {
25150 throw new Error("initializeWasm() must be awaited first!");
25152 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
25153 // debug statements here
25155 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25157 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: number): number {
25158 if(!isWasmInitialized) {
25159 throw new Error("initializeWasm() must be awaited first!");
25161 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
25162 return nativeResponseValue;
25164 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25166 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: number, val: number): void {
25167 if(!isWasmInitialized) {
25168 throw new Error("initializeWasm() must be awaited first!");
25170 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
25171 // debug statements here
25173 // 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);
25175 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 {
25176 if(!isWasmInitialized) {
25177 throw new Error("initializeWasm() must be awaited first!");
25179 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);
25180 return nativeResponseValue;
25182 // uintptr_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
25184 export function TxCreationKeys_clone_ptr(arg: number): number {
25185 if(!isWasmInitialized) {
25186 throw new Error("initializeWasm() must be awaited first!");
25188 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
25189 return nativeResponseValue;
25191 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
25193 export function TxCreationKeys_clone(orig: number): number {
25194 if(!isWasmInitialized) {
25195 throw new Error("initializeWasm() must be awaited first!");
25197 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
25198 return nativeResponseValue;
25200 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
25202 export function TxCreationKeys_write(obj: number): number {
25203 if(!isWasmInitialized) {
25204 throw new Error("initializeWasm() must be awaited first!");
25206 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
25207 return nativeResponseValue;
25209 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
25211 export function TxCreationKeys_read(ser: number): number {
25212 if(!isWasmInitialized) {
25213 throw new Error("initializeWasm() must be awaited first!");
25215 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
25216 return nativeResponseValue;
25218 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
25220 export function ChannelPublicKeys_free(this_obj: number): void {
25221 if(!isWasmInitialized) {
25222 throw new Error("initializeWasm() must be awaited first!");
25224 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
25225 // debug statements here
25227 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25229 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: number): number {
25230 if(!isWasmInitialized) {
25231 throw new Error("initializeWasm() must be awaited first!");
25233 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
25234 return nativeResponseValue;
25236 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25238 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: number, val: number): void {
25239 if(!isWasmInitialized) {
25240 throw new Error("initializeWasm() must be awaited first!");
25242 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
25243 // debug statements here
25245 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25247 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: number): number {
25248 if(!isWasmInitialized) {
25249 throw new Error("initializeWasm() must be awaited first!");
25251 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
25252 return nativeResponseValue;
25254 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25256 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: number, val: number): void {
25257 if(!isWasmInitialized) {
25258 throw new Error("initializeWasm() must be awaited first!");
25260 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
25261 // debug statements here
25263 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25265 export function ChannelPublicKeys_get_payment_point(this_ptr: number): number {
25266 if(!isWasmInitialized) {
25267 throw new Error("initializeWasm() must be awaited first!");
25269 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
25270 return nativeResponseValue;
25272 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25274 export function ChannelPublicKeys_set_payment_point(this_ptr: number, val: number): void {
25275 if(!isWasmInitialized) {
25276 throw new Error("initializeWasm() must be awaited first!");
25278 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
25279 // debug statements here
25281 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25283 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: number): number {
25284 if(!isWasmInitialized) {
25285 throw new Error("initializeWasm() must be awaited first!");
25287 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
25288 return nativeResponseValue;
25290 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25292 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
25293 if(!isWasmInitialized) {
25294 throw new Error("initializeWasm() must be awaited first!");
25296 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
25297 // debug statements here
25299 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25301 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: number): number {
25302 if(!isWasmInitialized) {
25303 throw new Error("initializeWasm() must be awaited first!");
25305 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
25306 return nativeResponseValue;
25308 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25310 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: number, val: number): void {
25311 if(!isWasmInitialized) {
25312 throw new Error("initializeWasm() must be awaited first!");
25314 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
25315 // debug statements here
25317 // 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);
25319 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 {
25320 if(!isWasmInitialized) {
25321 throw new Error("initializeWasm() must be awaited first!");
25323 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
25324 return nativeResponseValue;
25326 // uintptr_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
25328 export function ChannelPublicKeys_clone_ptr(arg: number): number {
25329 if(!isWasmInitialized) {
25330 throw new Error("initializeWasm() must be awaited first!");
25332 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
25333 return nativeResponseValue;
25335 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
25337 export function ChannelPublicKeys_clone(orig: number): number {
25338 if(!isWasmInitialized) {
25339 throw new Error("initializeWasm() must be awaited first!");
25341 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
25342 return nativeResponseValue;
25344 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
25346 export function ChannelPublicKeys_write(obj: number): number {
25347 if(!isWasmInitialized) {
25348 throw new Error("initializeWasm() must be awaited first!");
25350 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
25351 return nativeResponseValue;
25353 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
25355 export function ChannelPublicKeys_read(ser: number): number {
25356 if(!isWasmInitialized) {
25357 throw new Error("initializeWasm() must be awaited first!");
25359 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
25360 return nativeResponseValue;
25362 // 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);
25364 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 {
25365 if(!isWasmInitialized) {
25366 throw new Error("initializeWasm() must be awaited first!");
25368 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
25369 return nativeResponseValue;
25371 // 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);
25373 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: number, countersignatory_keys: number): number {
25374 if(!isWasmInitialized) {
25375 throw new Error("initializeWasm() must be awaited first!");
25377 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
25378 return nativeResponseValue;
25380 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
25382 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
25383 if(!isWasmInitialized) {
25384 throw new Error("initializeWasm() must be awaited first!");
25386 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
25387 return nativeResponseValue;
25389 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
25391 export function HTLCOutputInCommitment_free(this_obj: number): void {
25392 if(!isWasmInitialized) {
25393 throw new Error("initializeWasm() must be awaited first!");
25395 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
25396 // debug statements here
25398 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25400 export function HTLCOutputInCommitment_get_offered(this_ptr: number): boolean {
25401 if(!isWasmInitialized) {
25402 throw new Error("initializeWasm() must be awaited first!");
25404 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
25405 return nativeResponseValue;
25407 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
25409 export function HTLCOutputInCommitment_set_offered(this_ptr: number, val: boolean): void {
25410 if(!isWasmInitialized) {
25411 throw new Error("initializeWasm() must be awaited first!");
25413 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
25414 // debug statements here
25416 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25418 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: number): bigint {
25419 if(!isWasmInitialized) {
25420 throw new Error("initializeWasm() must be awaited first!");
25422 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
25423 return nativeResponseValue;
25425 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
25427 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: number, val: bigint): void {
25428 if(!isWasmInitialized) {
25429 throw new Error("initializeWasm() must be awaited first!");
25431 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
25432 // debug statements here
25434 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25436 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: number): number {
25437 if(!isWasmInitialized) {
25438 throw new Error("initializeWasm() must be awaited first!");
25440 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
25441 return nativeResponseValue;
25443 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
25445 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: number, val: number): void {
25446 if(!isWasmInitialized) {
25447 throw new Error("initializeWasm() must be awaited first!");
25449 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
25450 // debug statements here
25452 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
25454 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: number): number {
25455 if(!isWasmInitialized) {
25456 throw new Error("initializeWasm() must be awaited first!");
25458 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
25459 return nativeResponseValue;
25461 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25463 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: number, val: number): void {
25464 if(!isWasmInitialized) {
25465 throw new Error("initializeWasm() must be awaited first!");
25467 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
25468 // debug statements here
25470 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25472 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
25473 if(!isWasmInitialized) {
25474 throw new Error("initializeWasm() must be awaited first!");
25476 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
25477 return nativeResponseValue;
25479 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
25481 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: number, val: number): void {
25482 if(!isWasmInitialized) {
25483 throw new Error("initializeWasm() must be awaited first!");
25485 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
25486 // debug statements here
25488 // 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);
25490 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 {
25491 if(!isWasmInitialized) {
25492 throw new Error("initializeWasm() must be awaited first!");
25494 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
25495 return nativeResponseValue;
25497 // uintptr_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
25499 export function HTLCOutputInCommitment_clone_ptr(arg: number): number {
25500 if(!isWasmInitialized) {
25501 throw new Error("initializeWasm() must be awaited first!");
25503 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
25504 return nativeResponseValue;
25506 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
25508 export function HTLCOutputInCommitment_clone(orig: number): number {
25509 if(!isWasmInitialized) {
25510 throw new Error("initializeWasm() must be awaited first!");
25512 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
25513 return nativeResponseValue;
25515 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
25517 export function HTLCOutputInCommitment_write(obj: number): number {
25518 if(!isWasmInitialized) {
25519 throw new Error("initializeWasm() must be awaited first!");
25521 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
25522 return nativeResponseValue;
25524 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
25526 export function HTLCOutputInCommitment_read(ser: number): number {
25527 if(!isWasmInitialized) {
25528 throw new Error("initializeWasm() must be awaited first!");
25530 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
25531 return nativeResponseValue;
25533 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
25535 export function get_htlc_redeemscript(htlc: number, opt_anchors: boolean, keys: number): number {
25536 if(!isWasmInitialized) {
25537 throw new Error("initializeWasm() must be awaited first!");
25539 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
25540 return nativeResponseValue;
25542 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
25544 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
25545 if(!isWasmInitialized) {
25546 throw new Error("initializeWasm() must be awaited first!");
25548 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
25549 return nativeResponseValue;
25551 // 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);
25553 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 {
25554 if(!isWasmInitialized) {
25555 throw new Error("initializeWasm() must be awaited first!");
25557 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
25558 return nativeResponseValue;
25560 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
25562 export function get_anchor_redeemscript(funding_pubkey: number): number {
25563 if(!isWasmInitialized) {
25564 throw new Error("initializeWasm() must be awaited first!");
25566 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
25567 return nativeResponseValue;
25569 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
25571 export function ChannelTransactionParameters_free(this_obj: number): void {
25572 if(!isWasmInitialized) {
25573 throw new Error("initializeWasm() must be awaited first!");
25575 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
25576 // debug statements here
25578 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25580 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: number): number {
25581 if(!isWasmInitialized) {
25582 throw new Error("initializeWasm() must be awaited first!");
25584 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
25585 return nativeResponseValue;
25587 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
25589 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: number, val: number): void {
25590 if(!isWasmInitialized) {
25591 throw new Error("initializeWasm() must be awaited first!");
25593 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
25594 // debug statements here
25596 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25598 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: number): number {
25599 if(!isWasmInitialized) {
25600 throw new Error("initializeWasm() must be awaited first!");
25602 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
25603 return nativeResponseValue;
25605 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
25607 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: number, val: number): void {
25608 if(!isWasmInitialized) {
25609 throw new Error("initializeWasm() must be awaited first!");
25611 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
25612 // debug statements here
25614 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25616 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: number): boolean {
25617 if(!isWasmInitialized) {
25618 throw new Error("initializeWasm() must be awaited first!");
25620 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
25621 return nativeResponseValue;
25623 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
25625 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: number, val: boolean): void {
25626 if(!isWasmInitialized) {
25627 throw new Error("initializeWasm() must be awaited first!");
25629 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
25630 // debug statements here
25632 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25634 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: number): number {
25635 if(!isWasmInitialized) {
25636 throw new Error("initializeWasm() must be awaited first!");
25638 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
25639 return nativeResponseValue;
25641 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
25643 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: number, val: number): void {
25644 if(!isWasmInitialized) {
25645 throw new Error("initializeWasm() must be awaited first!");
25647 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
25648 // debug statements here
25650 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25652 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: number): number {
25653 if(!isWasmInitialized) {
25654 throw new Error("initializeWasm() must be awaited first!");
25656 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
25657 return nativeResponseValue;
25659 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
25661 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: number, val: number): void {
25662 if(!isWasmInitialized) {
25663 throw new Error("initializeWasm() must be awaited first!");
25665 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
25666 // debug statements here
25668 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25670 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: number): COption_NoneZ {
25671 if(!isWasmInitialized) {
25672 throw new Error("initializeWasm() must be awaited first!");
25674 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
25675 return nativeResponseValue;
25677 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
25679 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: number, val: COption_NoneZ): void {
25680 if(!isWasmInitialized) {
25681 throw new Error("initializeWasm() must be awaited first!");
25683 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
25684 // debug statements here
25686 // 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);
25688 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 {
25689 if(!isWasmInitialized) {
25690 throw new Error("initializeWasm() must be awaited first!");
25692 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);
25693 return nativeResponseValue;
25695 // uintptr_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
25697 export function ChannelTransactionParameters_clone_ptr(arg: number): number {
25698 if(!isWasmInitialized) {
25699 throw new Error("initializeWasm() must be awaited first!");
25701 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
25702 return nativeResponseValue;
25704 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
25706 export function ChannelTransactionParameters_clone(orig: number): number {
25707 if(!isWasmInitialized) {
25708 throw new Error("initializeWasm() must be awaited first!");
25710 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
25711 return nativeResponseValue;
25713 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
25715 export function CounterpartyChannelTransactionParameters_free(this_obj: number): void {
25716 if(!isWasmInitialized) {
25717 throw new Error("initializeWasm() must be awaited first!");
25719 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
25720 // debug statements here
25722 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
25724 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: number): number {
25725 if(!isWasmInitialized) {
25726 throw new Error("initializeWasm() must be awaited first!");
25728 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
25729 return nativeResponseValue;
25731 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
25733 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: number, val: number): void {
25734 if(!isWasmInitialized) {
25735 throw new Error("initializeWasm() must be awaited first!");
25737 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
25738 // debug statements here
25740 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
25742 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: number): number {
25743 if(!isWasmInitialized) {
25744 throw new Error("initializeWasm() must be awaited first!");
25746 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
25747 return nativeResponseValue;
25749 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
25751 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: number, val: number): void {
25752 if(!isWasmInitialized) {
25753 throw new Error("initializeWasm() must be awaited first!");
25755 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
25756 // debug statements here
25758 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
25760 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: number, selected_contest_delay_arg: number): number {
25761 if(!isWasmInitialized) {
25762 throw new Error("initializeWasm() must be awaited first!");
25764 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
25765 return nativeResponseValue;
25767 // uintptr_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
25769 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: number): number {
25770 if(!isWasmInitialized) {
25771 throw new Error("initializeWasm() must be awaited first!");
25773 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
25774 return nativeResponseValue;
25776 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
25778 export function CounterpartyChannelTransactionParameters_clone(orig: number): number {
25779 if(!isWasmInitialized) {
25780 throw new Error("initializeWasm() must be awaited first!");
25782 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
25783 return nativeResponseValue;
25785 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
25787 export function ChannelTransactionParameters_is_populated(this_arg: number): boolean {
25788 if(!isWasmInitialized) {
25789 throw new Error("initializeWasm() must be awaited first!");
25791 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
25792 return nativeResponseValue;
25794 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
25796 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: number): number {
25797 if(!isWasmInitialized) {
25798 throw new Error("initializeWasm() must be awaited first!");
25800 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
25801 return nativeResponseValue;
25803 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
25805 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: number): number {
25806 if(!isWasmInitialized) {
25807 throw new Error("initializeWasm() must be awaited first!");
25809 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
25810 return nativeResponseValue;
25812 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
25814 export function CounterpartyChannelTransactionParameters_write(obj: number): number {
25815 if(!isWasmInitialized) {
25816 throw new Error("initializeWasm() must be awaited first!");
25818 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
25819 return nativeResponseValue;
25821 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
25823 export function CounterpartyChannelTransactionParameters_read(ser: number): number {
25824 if(!isWasmInitialized) {
25825 throw new Error("initializeWasm() must be awaited first!");
25827 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
25828 return nativeResponseValue;
25830 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
25832 export function ChannelTransactionParameters_write(obj: number): number {
25833 if(!isWasmInitialized) {
25834 throw new Error("initializeWasm() must be awaited first!");
25836 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
25837 return nativeResponseValue;
25839 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
25841 export function ChannelTransactionParameters_read(ser: number): number {
25842 if(!isWasmInitialized) {
25843 throw new Error("initializeWasm() must be awaited first!");
25845 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
25846 return nativeResponseValue;
25848 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
25850 export function DirectedChannelTransactionParameters_free(this_obj: number): void {
25851 if(!isWasmInitialized) {
25852 throw new Error("initializeWasm() must be awaited first!");
25854 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
25855 // debug statements here
25857 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25859 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: number): number {
25860 if(!isWasmInitialized) {
25861 throw new Error("initializeWasm() must be awaited first!");
25863 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
25864 return nativeResponseValue;
25866 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25868 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: number): number {
25869 if(!isWasmInitialized) {
25870 throw new Error("initializeWasm() must be awaited first!");
25872 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
25873 return nativeResponseValue;
25875 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25877 export function DirectedChannelTransactionParameters_contest_delay(this_arg: number): number {
25878 if(!isWasmInitialized) {
25879 throw new Error("initializeWasm() must be awaited first!");
25881 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
25882 return nativeResponseValue;
25884 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25886 export function DirectedChannelTransactionParameters_is_outbound(this_arg: number): boolean {
25887 if(!isWasmInitialized) {
25888 throw new Error("initializeWasm() must be awaited first!");
25890 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
25891 return nativeResponseValue;
25893 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25895 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: number): number {
25896 if(!isWasmInitialized) {
25897 throw new Error("initializeWasm() must be awaited first!");
25899 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
25900 return nativeResponseValue;
25902 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
25904 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: number): boolean {
25905 if(!isWasmInitialized) {
25906 throw new Error("initializeWasm() must be awaited first!");
25908 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
25909 return nativeResponseValue;
25911 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
25913 export function HolderCommitmentTransaction_free(this_obj: number): void {
25914 if(!isWasmInitialized) {
25915 throw new Error("initializeWasm() must be awaited first!");
25917 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
25918 // debug statements here
25920 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
25922 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: number): number {
25923 if(!isWasmInitialized) {
25924 throw new Error("initializeWasm() must be awaited first!");
25926 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
25927 return nativeResponseValue;
25929 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
25931 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: number, val: number): void {
25932 if(!isWasmInitialized) {
25933 throw new Error("initializeWasm() must be awaited first!");
25935 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
25936 // debug statements here
25938 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
25940 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: number, val: number): void {
25941 if(!isWasmInitialized) {
25942 throw new Error("initializeWasm() must be awaited first!");
25944 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
25945 // debug statements here
25947 // uintptr_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
25949 export function HolderCommitmentTransaction_clone_ptr(arg: number): number {
25950 if(!isWasmInitialized) {
25951 throw new Error("initializeWasm() must be awaited first!");
25953 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
25954 return nativeResponseValue;
25956 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
25958 export function HolderCommitmentTransaction_clone(orig: number): number {
25959 if(!isWasmInitialized) {
25960 throw new Error("initializeWasm() must be awaited first!");
25962 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
25963 return nativeResponseValue;
25965 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
25967 export function HolderCommitmentTransaction_write(obj: number): number {
25968 if(!isWasmInitialized) {
25969 throw new Error("initializeWasm() must be awaited first!");
25971 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
25972 return nativeResponseValue;
25974 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
25976 export function HolderCommitmentTransaction_read(ser: number): number {
25977 if(!isWasmInitialized) {
25978 throw new Error("initializeWasm() must be awaited first!");
25980 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
25981 return nativeResponseValue;
25983 // 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);
25985 export function HolderCommitmentTransaction_new(commitment_tx: number, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): number {
25986 if(!isWasmInitialized) {
25987 throw new Error("initializeWasm() must be awaited first!");
25989 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
25990 return nativeResponseValue;
25992 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
25994 export function BuiltCommitmentTransaction_free(this_obj: number): void {
25995 if(!isWasmInitialized) {
25996 throw new Error("initializeWasm() must be awaited first!");
25998 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
25999 // debug statements here
26001 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
26003 export function BuiltCommitmentTransaction_get_transaction(this_ptr: number): number {
26004 if(!isWasmInitialized) {
26005 throw new Error("initializeWasm() must be awaited first!");
26007 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
26008 return nativeResponseValue;
26010 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
26012 export function BuiltCommitmentTransaction_set_transaction(this_ptr: number, val: number): void {
26013 if(!isWasmInitialized) {
26014 throw new Error("initializeWasm() must be awaited first!");
26016 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
26017 // debug statements here
26019 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
26021 export function BuiltCommitmentTransaction_get_txid(this_ptr: number): number {
26022 if(!isWasmInitialized) {
26023 throw new Error("initializeWasm() must be awaited first!");
26025 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
26026 return nativeResponseValue;
26028 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26030 export function BuiltCommitmentTransaction_set_txid(this_ptr: number, val: number): void {
26031 if(!isWasmInitialized) {
26032 throw new Error("initializeWasm() must be awaited first!");
26034 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
26035 // debug statements here
26037 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
26039 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): number {
26040 if(!isWasmInitialized) {
26041 throw new Error("initializeWasm() must be awaited first!");
26043 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
26044 return nativeResponseValue;
26046 // uintptr_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
26048 export function BuiltCommitmentTransaction_clone_ptr(arg: number): number {
26049 if(!isWasmInitialized) {
26050 throw new Error("initializeWasm() must be awaited first!");
26052 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
26053 return nativeResponseValue;
26055 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
26057 export function BuiltCommitmentTransaction_clone(orig: number): number {
26058 if(!isWasmInitialized) {
26059 throw new Error("initializeWasm() must be awaited first!");
26061 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
26062 return nativeResponseValue;
26064 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
26066 export function BuiltCommitmentTransaction_write(obj: number): number {
26067 if(!isWasmInitialized) {
26068 throw new Error("initializeWasm() must be awaited first!");
26070 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
26071 return nativeResponseValue;
26073 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
26075 export function BuiltCommitmentTransaction_read(ser: number): number {
26076 if(!isWasmInitialized) {
26077 throw new Error("initializeWasm() must be awaited first!");
26079 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
26080 return nativeResponseValue;
26082 // 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);
26084 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26085 if(!isWasmInitialized) {
26086 throw new Error("initializeWasm() must be awaited first!");
26088 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
26089 return nativeResponseValue;
26091 // 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);
26093 export function BuiltCommitmentTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26094 if(!isWasmInitialized) {
26095 throw new Error("initializeWasm() must be awaited first!");
26097 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
26098 return nativeResponseValue;
26100 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
26102 export function ClosingTransaction_free(this_obj: number): void {
26103 if(!isWasmInitialized) {
26104 throw new Error("initializeWasm() must be awaited first!");
26106 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
26107 // debug statements here
26109 // uintptr_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
26111 export function ClosingTransaction_clone_ptr(arg: number): number {
26112 if(!isWasmInitialized) {
26113 throw new Error("initializeWasm() must be awaited first!");
26115 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
26116 return nativeResponseValue;
26118 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
26120 export function ClosingTransaction_clone(orig: number): number {
26121 if(!isWasmInitialized) {
26122 throw new Error("initializeWasm() must be awaited first!");
26124 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
26125 return nativeResponseValue;
26127 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
26129 export function ClosingTransaction_hash(o: number): bigint {
26130 if(!isWasmInitialized) {
26131 throw new Error("initializeWasm() must be awaited first!");
26133 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
26134 return nativeResponseValue;
26136 // 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);
26138 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 {
26139 if(!isWasmInitialized) {
26140 throw new Error("initializeWasm() must be awaited first!");
26142 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
26143 return nativeResponseValue;
26145 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26147 export function ClosingTransaction_trust(this_arg: number): number {
26148 if(!isWasmInitialized) {
26149 throw new Error("initializeWasm() must be awaited first!");
26151 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
26152 return nativeResponseValue;
26154 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
26156 export function ClosingTransaction_verify(this_arg: number, funding_outpoint: number): number {
26157 if(!isWasmInitialized) {
26158 throw new Error("initializeWasm() must be awaited first!");
26160 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
26161 return nativeResponseValue;
26163 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26165 export function ClosingTransaction_to_holder_value_sat(this_arg: number): bigint {
26166 if(!isWasmInitialized) {
26167 throw new Error("initializeWasm() must be awaited first!");
26169 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
26170 return nativeResponseValue;
26172 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26174 export function ClosingTransaction_to_counterparty_value_sat(this_arg: number): bigint {
26175 if(!isWasmInitialized) {
26176 throw new Error("initializeWasm() must be awaited first!");
26178 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
26179 return nativeResponseValue;
26181 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26183 export function ClosingTransaction_to_holder_script(this_arg: number): number {
26184 if(!isWasmInitialized) {
26185 throw new Error("initializeWasm() must be awaited first!");
26187 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
26188 return nativeResponseValue;
26190 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26192 export function ClosingTransaction_to_counterparty_script(this_arg: number): number {
26193 if(!isWasmInitialized) {
26194 throw new Error("initializeWasm() must be awaited first!");
26196 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
26197 return nativeResponseValue;
26199 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
26201 export function TrustedClosingTransaction_free(this_obj: number): void {
26202 if(!isWasmInitialized) {
26203 throw new Error("initializeWasm() must be awaited first!");
26205 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
26206 // debug statements here
26208 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
26210 export function TrustedClosingTransaction_built_transaction(this_arg: number): number {
26211 if(!isWasmInitialized) {
26212 throw new Error("initializeWasm() must be awaited first!");
26214 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
26215 return nativeResponseValue;
26217 // 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);
26219 export function TrustedClosingTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26220 if(!isWasmInitialized) {
26221 throw new Error("initializeWasm() must be awaited first!");
26223 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
26224 return nativeResponseValue;
26226 // 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);
26228 export function TrustedClosingTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26229 if(!isWasmInitialized) {
26230 throw new Error("initializeWasm() must be awaited first!");
26232 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
26233 return nativeResponseValue;
26235 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
26237 export function CommitmentTransaction_free(this_obj: number): void {
26238 if(!isWasmInitialized) {
26239 throw new Error("initializeWasm() must be awaited first!");
26241 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
26242 // debug statements here
26244 // uintptr_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
26246 export function CommitmentTransaction_clone_ptr(arg: number): number {
26247 if(!isWasmInitialized) {
26248 throw new Error("initializeWasm() must be awaited first!");
26250 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
26251 return nativeResponseValue;
26253 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
26255 export function CommitmentTransaction_clone(orig: number): number {
26256 if(!isWasmInitialized) {
26257 throw new Error("initializeWasm() must be awaited first!");
26259 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
26260 return nativeResponseValue;
26262 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
26264 export function CommitmentTransaction_write(obj: number): number {
26265 if(!isWasmInitialized) {
26266 throw new Error("initializeWasm() must be awaited first!");
26268 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
26269 return nativeResponseValue;
26271 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
26273 export function CommitmentTransaction_read(ser: number): number {
26274 if(!isWasmInitialized) {
26275 throw new Error("initializeWasm() must be awaited first!");
26277 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
26278 return nativeResponseValue;
26280 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26282 export function CommitmentTransaction_commitment_number(this_arg: number): bigint {
26283 if(!isWasmInitialized) {
26284 throw new Error("initializeWasm() must be awaited first!");
26286 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
26287 return nativeResponseValue;
26289 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26291 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: number): bigint {
26292 if(!isWasmInitialized) {
26293 throw new Error("initializeWasm() must be awaited first!");
26295 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
26296 return nativeResponseValue;
26298 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26300 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: number): bigint {
26301 if(!isWasmInitialized) {
26302 throw new Error("initializeWasm() must be awaited first!");
26304 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
26305 return nativeResponseValue;
26307 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26309 export function CommitmentTransaction_feerate_per_kw(this_arg: number): number {
26310 if(!isWasmInitialized) {
26311 throw new Error("initializeWasm() must be awaited first!");
26313 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
26314 return nativeResponseValue;
26316 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26318 export function CommitmentTransaction_trust(this_arg: number): number {
26319 if(!isWasmInitialized) {
26320 throw new Error("initializeWasm() must be awaited first!");
26322 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
26323 return nativeResponseValue;
26325 // 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);
26327 export function CommitmentTransaction_verify(this_arg: number, channel_parameters: number, broadcaster_keys: number, countersignatory_keys: number): number {
26328 if(!isWasmInitialized) {
26329 throw new Error("initializeWasm() must be awaited first!");
26331 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
26332 return nativeResponseValue;
26334 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
26336 export function TrustedCommitmentTransaction_free(this_obj: number): void {
26337 if(!isWasmInitialized) {
26338 throw new Error("initializeWasm() must be awaited first!");
26340 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
26341 // debug statements here
26343 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26345 export function TrustedCommitmentTransaction_txid(this_arg: number): number {
26346 if(!isWasmInitialized) {
26347 throw new Error("initializeWasm() must be awaited first!");
26349 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
26350 return nativeResponseValue;
26352 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26354 export function TrustedCommitmentTransaction_built_transaction(this_arg: number): number {
26355 if(!isWasmInitialized) {
26356 throw new Error("initializeWasm() must be awaited first!");
26358 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
26359 return nativeResponseValue;
26361 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26363 export function TrustedCommitmentTransaction_keys(this_arg: number): number {
26364 if(!isWasmInitialized) {
26365 throw new Error("initializeWasm() must be awaited first!");
26367 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
26368 return nativeResponseValue;
26370 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26372 export function TrustedCommitmentTransaction_opt_anchors(this_arg: number): boolean {
26373 if(!isWasmInitialized) {
26374 throw new Error("initializeWasm() must be awaited first!");
26376 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
26377 return nativeResponseValue;
26379 // 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);
26381 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: number, htlc_base_key: number, channel_parameters: number): number {
26382 if(!isWasmInitialized) {
26383 throw new Error("initializeWasm() must be awaited first!");
26385 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
26386 return nativeResponseValue;
26388 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
26390 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
26391 if(!isWasmInitialized) {
26392 throw new Error("initializeWasm() must be awaited first!");
26394 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
26395 return nativeResponseValue;
26397 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
26399 export function InitFeatures_eq(a: number, b: number): boolean {
26400 if(!isWasmInitialized) {
26401 throw new Error("initializeWasm() must be awaited first!");
26403 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
26404 return nativeResponseValue;
26406 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
26408 export function NodeFeatures_eq(a: number, b: number): boolean {
26409 if(!isWasmInitialized) {
26410 throw new Error("initializeWasm() must be awaited first!");
26412 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
26413 return nativeResponseValue;
26415 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
26417 export function ChannelFeatures_eq(a: number, b: number): boolean {
26418 if(!isWasmInitialized) {
26419 throw new Error("initializeWasm() must be awaited first!");
26421 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
26422 return nativeResponseValue;
26424 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
26426 export function InvoiceFeatures_eq(a: number, b: number): boolean {
26427 if(!isWasmInitialized) {
26428 throw new Error("initializeWasm() must be awaited first!");
26430 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
26431 return nativeResponseValue;
26433 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
26435 export function ChannelTypeFeatures_eq(a: number, b: number): boolean {
26436 if(!isWasmInitialized) {
26437 throw new Error("initializeWasm() must be awaited first!");
26439 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
26440 return nativeResponseValue;
26442 // uintptr_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
26444 export function InitFeatures_clone_ptr(arg: number): number {
26445 if(!isWasmInitialized) {
26446 throw new Error("initializeWasm() must be awaited first!");
26448 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
26449 return nativeResponseValue;
26451 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
26453 export function InitFeatures_clone(orig: number): number {
26454 if(!isWasmInitialized) {
26455 throw new Error("initializeWasm() must be awaited first!");
26457 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
26458 return nativeResponseValue;
26460 // uintptr_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
26462 export function NodeFeatures_clone_ptr(arg: number): number {
26463 if(!isWasmInitialized) {
26464 throw new Error("initializeWasm() must be awaited first!");
26466 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
26467 return nativeResponseValue;
26469 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
26471 export function NodeFeatures_clone(orig: number): number {
26472 if(!isWasmInitialized) {
26473 throw new Error("initializeWasm() must be awaited first!");
26475 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
26476 return nativeResponseValue;
26478 // uintptr_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
26480 export function ChannelFeatures_clone_ptr(arg: number): number {
26481 if(!isWasmInitialized) {
26482 throw new Error("initializeWasm() must be awaited first!");
26484 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
26485 return nativeResponseValue;
26487 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
26489 export function ChannelFeatures_clone(orig: number): number {
26490 if(!isWasmInitialized) {
26491 throw new Error("initializeWasm() must be awaited first!");
26493 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
26494 return nativeResponseValue;
26496 // uintptr_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
26498 export function InvoiceFeatures_clone_ptr(arg: number): number {
26499 if(!isWasmInitialized) {
26500 throw new Error("initializeWasm() must be awaited first!");
26502 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
26503 return nativeResponseValue;
26505 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
26507 export function InvoiceFeatures_clone(orig: number): number {
26508 if(!isWasmInitialized) {
26509 throw new Error("initializeWasm() must be awaited first!");
26511 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
26512 return nativeResponseValue;
26514 // uintptr_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
26516 export function ChannelTypeFeatures_clone_ptr(arg: number): number {
26517 if(!isWasmInitialized) {
26518 throw new Error("initializeWasm() must be awaited first!");
26520 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
26521 return nativeResponseValue;
26523 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
26525 export function ChannelTypeFeatures_clone(orig: number): number {
26526 if(!isWasmInitialized) {
26527 throw new Error("initializeWasm() must be awaited first!");
26529 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
26530 return nativeResponseValue;
26532 // void InitFeatures_free(struct LDKInitFeatures this_obj);
26534 export function InitFeatures_free(this_obj: number): void {
26535 if(!isWasmInitialized) {
26536 throw new Error("initializeWasm() must be awaited first!");
26538 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
26539 // debug statements here
26541 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
26543 export function NodeFeatures_free(this_obj: number): void {
26544 if(!isWasmInitialized) {
26545 throw new Error("initializeWasm() must be awaited first!");
26547 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
26548 // debug statements here
26550 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
26552 export function ChannelFeatures_free(this_obj: number): void {
26553 if(!isWasmInitialized) {
26554 throw new Error("initializeWasm() must be awaited first!");
26556 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
26557 // debug statements here
26559 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
26561 export function InvoiceFeatures_free(this_obj: number): void {
26562 if(!isWasmInitialized) {
26563 throw new Error("initializeWasm() must be awaited first!");
26565 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
26566 // debug statements here
26568 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
26570 export function ChannelTypeFeatures_free(this_obj: number): void {
26571 if(!isWasmInitialized) {
26572 throw new Error("initializeWasm() must be awaited first!");
26574 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
26575 // debug statements here
26577 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
26579 export function InitFeatures_empty(): number {
26580 if(!isWasmInitialized) {
26581 throw new Error("initializeWasm() must be awaited first!");
26583 const nativeResponseValue = wasm.TS_InitFeatures_empty();
26584 return nativeResponseValue;
26586 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
26588 export function InitFeatures_known(): number {
26589 if(!isWasmInitialized) {
26590 throw new Error("initializeWasm() must be awaited first!");
26592 const nativeResponseValue = wasm.TS_InitFeatures_known();
26593 return nativeResponseValue;
26595 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26597 export function InitFeatures_requires_unknown_bits(this_arg: number): boolean {
26598 if(!isWasmInitialized) {
26599 throw new Error("initializeWasm() must be awaited first!");
26601 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
26602 return nativeResponseValue;
26604 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
26606 export function NodeFeatures_empty(): number {
26607 if(!isWasmInitialized) {
26608 throw new Error("initializeWasm() must be awaited first!");
26610 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
26611 return nativeResponseValue;
26613 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
26615 export function NodeFeatures_known(): number {
26616 if(!isWasmInitialized) {
26617 throw new Error("initializeWasm() must be awaited first!");
26619 const nativeResponseValue = wasm.TS_NodeFeatures_known();
26620 return nativeResponseValue;
26622 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
26624 export function NodeFeatures_requires_unknown_bits(this_arg: number): boolean {
26625 if(!isWasmInitialized) {
26626 throw new Error("initializeWasm() must be awaited first!");
26628 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
26629 return nativeResponseValue;
26631 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
26633 export function ChannelFeatures_empty(): number {
26634 if(!isWasmInitialized) {
26635 throw new Error("initializeWasm() must be awaited first!");
26637 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
26638 return nativeResponseValue;
26640 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
26642 export function ChannelFeatures_known(): number {
26643 if(!isWasmInitialized) {
26644 throw new Error("initializeWasm() must be awaited first!");
26646 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
26647 return nativeResponseValue;
26649 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
26651 export function ChannelFeatures_requires_unknown_bits(this_arg: number): boolean {
26652 if(!isWasmInitialized) {
26653 throw new Error("initializeWasm() must be awaited first!");
26655 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
26656 return nativeResponseValue;
26658 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
26660 export function InvoiceFeatures_empty(): number {
26661 if(!isWasmInitialized) {
26662 throw new Error("initializeWasm() must be awaited first!");
26664 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
26665 return nativeResponseValue;
26667 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
26669 export function InvoiceFeatures_known(): number {
26670 if(!isWasmInitialized) {
26671 throw new Error("initializeWasm() must be awaited first!");
26673 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
26674 return nativeResponseValue;
26676 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
26678 export function InvoiceFeatures_requires_unknown_bits(this_arg: number): boolean {
26679 if(!isWasmInitialized) {
26680 throw new Error("initializeWasm() must be awaited first!");
26682 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
26683 return nativeResponseValue;
26685 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
26687 export function ChannelTypeFeatures_empty(): number {
26688 if(!isWasmInitialized) {
26689 throw new Error("initializeWasm() must be awaited first!");
26691 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
26692 return nativeResponseValue;
26694 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
26696 export function ChannelTypeFeatures_known(): number {
26697 if(!isWasmInitialized) {
26698 throw new Error("initializeWasm() must be awaited first!");
26700 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
26701 return nativeResponseValue;
26703 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
26705 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: number): boolean {
26706 if(!isWasmInitialized) {
26707 throw new Error("initializeWasm() must be awaited first!");
26709 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
26710 return nativeResponseValue;
26712 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
26714 export function InitFeatures_write(obj: number): number {
26715 if(!isWasmInitialized) {
26716 throw new Error("initializeWasm() must be awaited first!");
26718 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
26719 return nativeResponseValue;
26721 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
26723 export function InitFeatures_read(ser: number): number {
26724 if(!isWasmInitialized) {
26725 throw new Error("initializeWasm() must be awaited first!");
26727 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
26728 return nativeResponseValue;
26730 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
26732 export function ChannelFeatures_write(obj: number): number {
26733 if(!isWasmInitialized) {
26734 throw new Error("initializeWasm() must be awaited first!");
26736 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
26737 return nativeResponseValue;
26739 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
26741 export function ChannelFeatures_read(ser: number): number {
26742 if(!isWasmInitialized) {
26743 throw new Error("initializeWasm() must be awaited first!");
26745 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
26746 return nativeResponseValue;
26748 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
26750 export function NodeFeatures_write(obj: number): number {
26751 if(!isWasmInitialized) {
26752 throw new Error("initializeWasm() must be awaited first!");
26754 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
26755 return nativeResponseValue;
26757 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
26759 export function NodeFeatures_read(ser: number): number {
26760 if(!isWasmInitialized) {
26761 throw new Error("initializeWasm() must be awaited first!");
26763 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
26764 return nativeResponseValue;
26766 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
26768 export function InvoiceFeatures_write(obj: number): number {
26769 if(!isWasmInitialized) {
26770 throw new Error("initializeWasm() must be awaited first!");
26772 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
26773 return nativeResponseValue;
26775 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
26777 export function InvoiceFeatures_read(ser: number): number {
26778 if(!isWasmInitialized) {
26779 throw new Error("initializeWasm() must be awaited first!");
26781 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
26782 return nativeResponseValue;
26784 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
26786 export function ChannelTypeFeatures_write(obj: number): number {
26787 if(!isWasmInitialized) {
26788 throw new Error("initializeWasm() must be awaited first!");
26790 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
26791 return nativeResponseValue;
26793 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
26795 export function ChannelTypeFeatures_read(ser: number): number {
26796 if(!isWasmInitialized) {
26797 throw new Error("initializeWasm() must be awaited first!");
26799 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
26800 return nativeResponseValue;
26802 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
26804 export function InitFeatures_set_data_loss_protect_optional(this_arg: number): void {
26805 if(!isWasmInitialized) {
26806 throw new Error("initializeWasm() must be awaited first!");
26808 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
26809 // debug statements here
26811 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
26813 export function InitFeatures_set_data_loss_protect_required(this_arg: number): void {
26814 if(!isWasmInitialized) {
26815 throw new Error("initializeWasm() must be awaited first!");
26817 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
26818 // debug statements here
26820 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26822 export function InitFeatures_supports_data_loss_protect(this_arg: number): boolean {
26823 if(!isWasmInitialized) {
26824 throw new Error("initializeWasm() must be awaited first!");
26826 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
26827 return nativeResponseValue;
26829 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
26831 export function NodeFeatures_set_data_loss_protect_optional(this_arg: number): void {
26832 if(!isWasmInitialized) {
26833 throw new Error("initializeWasm() must be awaited first!");
26835 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
26836 // debug statements here
26838 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
26840 export function NodeFeatures_set_data_loss_protect_required(this_arg: number): void {
26841 if(!isWasmInitialized) {
26842 throw new Error("initializeWasm() must be awaited first!");
26844 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
26845 // debug statements here
26847 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
26849 export function NodeFeatures_supports_data_loss_protect(this_arg: number): boolean {
26850 if(!isWasmInitialized) {
26851 throw new Error("initializeWasm() must be awaited first!");
26853 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
26854 return nativeResponseValue;
26856 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26858 export function InitFeatures_requires_data_loss_protect(this_arg: number): boolean {
26859 if(!isWasmInitialized) {
26860 throw new Error("initializeWasm() must be awaited first!");
26862 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
26863 return nativeResponseValue;
26865 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
26867 export function NodeFeatures_requires_data_loss_protect(this_arg: number): boolean {
26868 if(!isWasmInitialized) {
26869 throw new Error("initializeWasm() must be awaited first!");
26871 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
26872 return nativeResponseValue;
26874 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
26876 export function InitFeatures_set_initial_routing_sync_optional(this_arg: number): void {
26877 if(!isWasmInitialized) {
26878 throw new Error("initializeWasm() must be awaited first!");
26880 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
26881 // debug statements here
26883 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
26885 export function InitFeatures_set_initial_routing_sync_required(this_arg: number): void {
26886 if(!isWasmInitialized) {
26887 throw new Error("initializeWasm() must be awaited first!");
26889 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
26890 // debug statements here
26892 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26894 export function InitFeatures_initial_routing_sync(this_arg: number): boolean {
26895 if(!isWasmInitialized) {
26896 throw new Error("initializeWasm() must be awaited first!");
26898 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
26899 return nativeResponseValue;
26901 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
26903 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: number): void {
26904 if(!isWasmInitialized) {
26905 throw new Error("initializeWasm() must be awaited first!");
26907 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
26908 // debug statements here
26910 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
26912 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: number): void {
26913 if(!isWasmInitialized) {
26914 throw new Error("initializeWasm() must be awaited first!");
26916 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
26917 // debug statements here
26919 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26921 export function InitFeatures_supports_upfront_shutdown_script(this_arg: number): boolean {
26922 if(!isWasmInitialized) {
26923 throw new Error("initializeWasm() must be awaited first!");
26925 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
26926 return nativeResponseValue;
26928 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
26930 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: number): void {
26931 if(!isWasmInitialized) {
26932 throw new Error("initializeWasm() must be awaited first!");
26934 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
26935 // debug statements here
26937 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
26939 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: number): void {
26940 if(!isWasmInitialized) {
26941 throw new Error("initializeWasm() must be awaited first!");
26943 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
26944 // debug statements here
26946 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
26948 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: number): boolean {
26949 if(!isWasmInitialized) {
26950 throw new Error("initializeWasm() must be awaited first!");
26952 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
26953 return nativeResponseValue;
26955 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26957 export function InitFeatures_requires_upfront_shutdown_script(this_arg: number): boolean {
26958 if(!isWasmInitialized) {
26959 throw new Error("initializeWasm() must be awaited first!");
26961 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
26962 return nativeResponseValue;
26964 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
26966 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: number): boolean {
26967 if(!isWasmInitialized) {
26968 throw new Error("initializeWasm() must be awaited first!");
26970 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
26971 return nativeResponseValue;
26973 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
26975 export function InitFeatures_set_gossip_queries_optional(this_arg: number): void {
26976 if(!isWasmInitialized) {
26977 throw new Error("initializeWasm() must be awaited first!");
26979 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
26980 // debug statements here
26982 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
26984 export function InitFeatures_set_gossip_queries_required(this_arg: number): void {
26985 if(!isWasmInitialized) {
26986 throw new Error("initializeWasm() must be awaited first!");
26988 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
26989 // debug statements here
26991 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26993 export function InitFeatures_supports_gossip_queries(this_arg: number): boolean {
26994 if(!isWasmInitialized) {
26995 throw new Error("initializeWasm() must be awaited first!");
26997 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
26998 return nativeResponseValue;
27000 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27002 export function NodeFeatures_set_gossip_queries_optional(this_arg: number): void {
27003 if(!isWasmInitialized) {
27004 throw new Error("initializeWasm() must be awaited first!");
27006 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
27007 // debug statements here
27009 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27011 export function NodeFeatures_set_gossip_queries_required(this_arg: number): void {
27012 if(!isWasmInitialized) {
27013 throw new Error("initializeWasm() must be awaited first!");
27015 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
27016 // debug statements here
27018 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27020 export function NodeFeatures_supports_gossip_queries(this_arg: number): boolean {
27021 if(!isWasmInitialized) {
27022 throw new Error("initializeWasm() must be awaited first!");
27024 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
27025 return nativeResponseValue;
27027 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27029 export function InitFeatures_requires_gossip_queries(this_arg: number): boolean {
27030 if(!isWasmInitialized) {
27031 throw new Error("initializeWasm() must be awaited first!");
27033 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
27034 return nativeResponseValue;
27036 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27038 export function NodeFeatures_requires_gossip_queries(this_arg: number): boolean {
27039 if(!isWasmInitialized) {
27040 throw new Error("initializeWasm() must be awaited first!");
27042 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
27043 return nativeResponseValue;
27045 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27047 export function InitFeatures_set_variable_length_onion_optional(this_arg: number): void {
27048 if(!isWasmInitialized) {
27049 throw new Error("initializeWasm() must be awaited first!");
27051 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
27052 // debug statements here
27054 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27056 export function InitFeatures_set_variable_length_onion_required(this_arg: number): void {
27057 if(!isWasmInitialized) {
27058 throw new Error("initializeWasm() must be awaited first!");
27060 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
27061 // debug statements here
27063 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27065 export function InitFeatures_supports_variable_length_onion(this_arg: number): boolean {
27066 if(!isWasmInitialized) {
27067 throw new Error("initializeWasm() must be awaited first!");
27069 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
27070 return nativeResponseValue;
27072 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27074 export function NodeFeatures_set_variable_length_onion_optional(this_arg: number): void {
27075 if(!isWasmInitialized) {
27076 throw new Error("initializeWasm() must be awaited first!");
27078 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
27079 // debug statements here
27081 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27083 export function NodeFeatures_set_variable_length_onion_required(this_arg: number): void {
27084 if(!isWasmInitialized) {
27085 throw new Error("initializeWasm() must be awaited first!");
27087 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
27088 // debug statements here
27090 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27092 export function NodeFeatures_supports_variable_length_onion(this_arg: number): boolean {
27093 if(!isWasmInitialized) {
27094 throw new Error("initializeWasm() must be awaited first!");
27096 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
27097 return nativeResponseValue;
27099 // void InvoiceFeatures_set_variable_length_onion_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27101 export function InvoiceFeatures_set_variable_length_onion_optional(this_arg: number): void {
27102 if(!isWasmInitialized) {
27103 throw new Error("initializeWasm() must be awaited first!");
27105 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_optional(this_arg);
27106 // debug statements here
27108 // void InvoiceFeatures_set_variable_length_onion_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27110 export function InvoiceFeatures_set_variable_length_onion_required(this_arg: number): void {
27111 if(!isWasmInitialized) {
27112 throw new Error("initializeWasm() must be awaited first!");
27114 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_required(this_arg);
27115 // debug statements here
27117 // MUST_USE_RES bool InvoiceFeatures_supports_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27119 export function InvoiceFeatures_supports_variable_length_onion(this_arg: number): boolean {
27120 if(!isWasmInitialized) {
27121 throw new Error("initializeWasm() must be awaited first!");
27123 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_variable_length_onion(this_arg);
27124 return nativeResponseValue;
27126 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27128 export function InitFeatures_requires_variable_length_onion(this_arg: number): boolean {
27129 if(!isWasmInitialized) {
27130 throw new Error("initializeWasm() must be awaited first!");
27132 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
27133 return nativeResponseValue;
27135 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27137 export function NodeFeatures_requires_variable_length_onion(this_arg: number): boolean {
27138 if(!isWasmInitialized) {
27139 throw new Error("initializeWasm() must be awaited first!");
27141 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
27142 return nativeResponseValue;
27144 // MUST_USE_RES bool InvoiceFeatures_requires_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27146 export function InvoiceFeatures_requires_variable_length_onion(this_arg: number): boolean {
27147 if(!isWasmInitialized) {
27148 throw new Error("initializeWasm() must be awaited first!");
27150 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_variable_length_onion(this_arg);
27151 return nativeResponseValue;
27153 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27155 export function InitFeatures_set_static_remote_key_optional(this_arg: number): void {
27156 if(!isWasmInitialized) {
27157 throw new Error("initializeWasm() must be awaited first!");
27159 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
27160 // debug statements here
27162 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27164 export function InitFeatures_set_static_remote_key_required(this_arg: number): void {
27165 if(!isWasmInitialized) {
27166 throw new Error("initializeWasm() must be awaited first!");
27168 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
27169 // debug statements here
27171 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27173 export function InitFeatures_supports_static_remote_key(this_arg: number): boolean {
27174 if(!isWasmInitialized) {
27175 throw new Error("initializeWasm() must be awaited first!");
27177 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
27178 return nativeResponseValue;
27180 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27182 export function NodeFeatures_set_static_remote_key_optional(this_arg: number): void {
27183 if(!isWasmInitialized) {
27184 throw new Error("initializeWasm() must be awaited first!");
27186 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
27187 // debug statements here
27189 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27191 export function NodeFeatures_set_static_remote_key_required(this_arg: number): void {
27192 if(!isWasmInitialized) {
27193 throw new Error("initializeWasm() must be awaited first!");
27195 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
27196 // debug statements here
27198 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27200 export function NodeFeatures_supports_static_remote_key(this_arg: number): boolean {
27201 if(!isWasmInitialized) {
27202 throw new Error("initializeWasm() must be awaited first!");
27204 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
27205 return nativeResponseValue;
27207 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27209 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: number): void {
27210 if(!isWasmInitialized) {
27211 throw new Error("initializeWasm() must be awaited first!");
27213 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
27214 // debug statements here
27216 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27218 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: number): void {
27219 if(!isWasmInitialized) {
27220 throw new Error("initializeWasm() must be awaited first!");
27222 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
27223 // debug statements here
27225 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27227 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: number): boolean {
27228 if(!isWasmInitialized) {
27229 throw new Error("initializeWasm() must be awaited first!");
27231 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
27232 return nativeResponseValue;
27234 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27236 export function InitFeatures_requires_static_remote_key(this_arg: number): boolean {
27237 if(!isWasmInitialized) {
27238 throw new Error("initializeWasm() must be awaited first!");
27240 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
27241 return nativeResponseValue;
27243 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27245 export function NodeFeatures_requires_static_remote_key(this_arg: number): boolean {
27246 if(!isWasmInitialized) {
27247 throw new Error("initializeWasm() must be awaited first!");
27249 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
27250 return nativeResponseValue;
27252 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27254 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: number): boolean {
27255 if(!isWasmInitialized) {
27256 throw new Error("initializeWasm() must be awaited first!");
27258 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
27259 return nativeResponseValue;
27261 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27263 export function InitFeatures_set_payment_secret_optional(this_arg: number): void {
27264 if(!isWasmInitialized) {
27265 throw new Error("initializeWasm() must be awaited first!");
27267 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
27268 // debug statements here
27270 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27272 export function InitFeatures_set_payment_secret_required(this_arg: number): void {
27273 if(!isWasmInitialized) {
27274 throw new Error("initializeWasm() must be awaited first!");
27276 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
27277 // debug statements here
27279 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27281 export function InitFeatures_supports_payment_secret(this_arg: number): boolean {
27282 if(!isWasmInitialized) {
27283 throw new Error("initializeWasm() must be awaited first!");
27285 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
27286 return nativeResponseValue;
27288 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27290 export function NodeFeatures_set_payment_secret_optional(this_arg: number): void {
27291 if(!isWasmInitialized) {
27292 throw new Error("initializeWasm() must be awaited first!");
27294 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
27295 // debug statements here
27297 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27299 export function NodeFeatures_set_payment_secret_required(this_arg: number): void {
27300 if(!isWasmInitialized) {
27301 throw new Error("initializeWasm() must be awaited first!");
27303 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
27304 // debug statements here
27306 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27308 export function NodeFeatures_supports_payment_secret(this_arg: number): boolean {
27309 if(!isWasmInitialized) {
27310 throw new Error("initializeWasm() must be awaited first!");
27312 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
27313 return nativeResponseValue;
27315 // void InvoiceFeatures_set_payment_secret_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27317 export function InvoiceFeatures_set_payment_secret_optional(this_arg: number): void {
27318 if(!isWasmInitialized) {
27319 throw new Error("initializeWasm() must be awaited first!");
27321 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_optional(this_arg);
27322 // debug statements here
27324 // void InvoiceFeatures_set_payment_secret_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27326 export function InvoiceFeatures_set_payment_secret_required(this_arg: number): void {
27327 if(!isWasmInitialized) {
27328 throw new Error("initializeWasm() must be awaited first!");
27330 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_required(this_arg);
27331 // debug statements here
27333 // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27335 export function InvoiceFeatures_supports_payment_secret(this_arg: number): boolean {
27336 if(!isWasmInitialized) {
27337 throw new Error("initializeWasm() must be awaited first!");
27339 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_payment_secret(this_arg);
27340 return nativeResponseValue;
27342 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27344 export function InitFeatures_requires_payment_secret(this_arg: number): boolean {
27345 if(!isWasmInitialized) {
27346 throw new Error("initializeWasm() must be awaited first!");
27348 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
27349 return nativeResponseValue;
27351 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27353 export function NodeFeatures_requires_payment_secret(this_arg: number): boolean {
27354 if(!isWasmInitialized) {
27355 throw new Error("initializeWasm() must be awaited first!");
27357 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
27358 return nativeResponseValue;
27360 // MUST_USE_RES bool InvoiceFeatures_requires_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27362 export function InvoiceFeatures_requires_payment_secret(this_arg: number): boolean {
27363 if(!isWasmInitialized) {
27364 throw new Error("initializeWasm() must be awaited first!");
27366 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_payment_secret(this_arg);
27367 return nativeResponseValue;
27369 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27371 export function InitFeatures_set_basic_mpp_optional(this_arg: number): void {
27372 if(!isWasmInitialized) {
27373 throw new Error("initializeWasm() must be awaited first!");
27375 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
27376 // debug statements here
27378 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27380 export function InitFeatures_set_basic_mpp_required(this_arg: number): void {
27381 if(!isWasmInitialized) {
27382 throw new Error("initializeWasm() must be awaited first!");
27384 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
27385 // debug statements here
27387 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27389 export function InitFeatures_supports_basic_mpp(this_arg: number): boolean {
27390 if(!isWasmInitialized) {
27391 throw new Error("initializeWasm() must be awaited first!");
27393 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
27394 return nativeResponseValue;
27396 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27398 export function NodeFeatures_set_basic_mpp_optional(this_arg: number): void {
27399 if(!isWasmInitialized) {
27400 throw new Error("initializeWasm() must be awaited first!");
27402 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
27403 // debug statements here
27405 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27407 export function NodeFeatures_set_basic_mpp_required(this_arg: number): void {
27408 if(!isWasmInitialized) {
27409 throw new Error("initializeWasm() must be awaited first!");
27411 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
27412 // debug statements here
27414 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27416 export function NodeFeatures_supports_basic_mpp(this_arg: number): boolean {
27417 if(!isWasmInitialized) {
27418 throw new Error("initializeWasm() must be awaited first!");
27420 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
27421 return nativeResponseValue;
27423 // void InvoiceFeatures_set_basic_mpp_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27425 export function InvoiceFeatures_set_basic_mpp_optional(this_arg: number): void {
27426 if(!isWasmInitialized) {
27427 throw new Error("initializeWasm() must be awaited first!");
27429 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_optional(this_arg);
27430 // debug statements here
27432 // void InvoiceFeatures_set_basic_mpp_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27434 export function InvoiceFeatures_set_basic_mpp_required(this_arg: number): void {
27435 if(!isWasmInitialized) {
27436 throw new Error("initializeWasm() must be awaited first!");
27438 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_required(this_arg);
27439 // debug statements here
27441 // MUST_USE_RES bool InvoiceFeatures_supports_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27443 export function InvoiceFeatures_supports_basic_mpp(this_arg: number): boolean {
27444 if(!isWasmInitialized) {
27445 throw new Error("initializeWasm() must be awaited first!");
27447 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_basic_mpp(this_arg);
27448 return nativeResponseValue;
27450 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27452 export function InitFeatures_requires_basic_mpp(this_arg: number): boolean {
27453 if(!isWasmInitialized) {
27454 throw new Error("initializeWasm() must be awaited first!");
27456 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
27457 return nativeResponseValue;
27459 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27461 export function NodeFeatures_requires_basic_mpp(this_arg: number): boolean {
27462 if(!isWasmInitialized) {
27463 throw new Error("initializeWasm() must be awaited first!");
27465 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
27466 return nativeResponseValue;
27468 // MUST_USE_RES bool InvoiceFeatures_requires_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27470 export function InvoiceFeatures_requires_basic_mpp(this_arg: number): boolean {
27471 if(!isWasmInitialized) {
27472 throw new Error("initializeWasm() must be awaited first!");
27474 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_basic_mpp(this_arg);
27475 return nativeResponseValue;
27477 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27479 export function InitFeatures_set_wumbo_optional(this_arg: number): void {
27480 if(!isWasmInitialized) {
27481 throw new Error("initializeWasm() must be awaited first!");
27483 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
27484 // debug statements here
27486 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27488 export function InitFeatures_set_wumbo_required(this_arg: number): void {
27489 if(!isWasmInitialized) {
27490 throw new Error("initializeWasm() must be awaited first!");
27492 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
27493 // debug statements here
27495 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27497 export function InitFeatures_supports_wumbo(this_arg: number): boolean {
27498 if(!isWasmInitialized) {
27499 throw new Error("initializeWasm() must be awaited first!");
27501 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
27502 return nativeResponseValue;
27504 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27506 export function NodeFeatures_set_wumbo_optional(this_arg: number): void {
27507 if(!isWasmInitialized) {
27508 throw new Error("initializeWasm() must be awaited first!");
27510 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
27511 // debug statements here
27513 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27515 export function NodeFeatures_set_wumbo_required(this_arg: number): void {
27516 if(!isWasmInitialized) {
27517 throw new Error("initializeWasm() must be awaited first!");
27519 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
27520 // debug statements here
27522 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27524 export function NodeFeatures_supports_wumbo(this_arg: number): boolean {
27525 if(!isWasmInitialized) {
27526 throw new Error("initializeWasm() must be awaited first!");
27528 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
27529 return nativeResponseValue;
27531 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27533 export function InitFeatures_requires_wumbo(this_arg: number): boolean {
27534 if(!isWasmInitialized) {
27535 throw new Error("initializeWasm() must be awaited first!");
27537 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
27538 return nativeResponseValue;
27540 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27542 export function NodeFeatures_requires_wumbo(this_arg: number): boolean {
27543 if(!isWasmInitialized) {
27544 throw new Error("initializeWasm() must be awaited first!");
27546 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
27547 return nativeResponseValue;
27549 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27551 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: number): void {
27552 if(!isWasmInitialized) {
27553 throw new Error("initializeWasm() must be awaited first!");
27555 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
27556 // debug statements here
27558 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27560 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: number): void {
27561 if(!isWasmInitialized) {
27562 throw new Error("initializeWasm() must be awaited first!");
27564 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
27565 // debug statements here
27567 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27569 export function InitFeatures_supports_shutdown_anysegwit(this_arg: number): boolean {
27570 if(!isWasmInitialized) {
27571 throw new Error("initializeWasm() must be awaited first!");
27573 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
27574 return nativeResponseValue;
27576 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27578 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: number): void {
27579 if(!isWasmInitialized) {
27580 throw new Error("initializeWasm() must be awaited first!");
27582 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
27583 // debug statements here
27585 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27587 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: number): void {
27588 if(!isWasmInitialized) {
27589 throw new Error("initializeWasm() must be awaited first!");
27591 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
27592 // debug statements here
27594 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27596 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: number): boolean {
27597 if(!isWasmInitialized) {
27598 throw new Error("initializeWasm() must be awaited first!");
27600 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
27601 return nativeResponseValue;
27603 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27605 export function InitFeatures_requires_shutdown_anysegwit(this_arg: number): boolean {
27606 if(!isWasmInitialized) {
27607 throw new Error("initializeWasm() must be awaited first!");
27609 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
27610 return nativeResponseValue;
27612 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27614 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: number): boolean {
27615 if(!isWasmInitialized) {
27616 throw new Error("initializeWasm() must be awaited first!");
27618 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
27619 return nativeResponseValue;
27621 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27623 export function InitFeatures_set_channel_type_optional(this_arg: number): void {
27624 if(!isWasmInitialized) {
27625 throw new Error("initializeWasm() must be awaited first!");
27627 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
27628 // debug statements here
27630 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27632 export function InitFeatures_set_channel_type_required(this_arg: number): void {
27633 if(!isWasmInitialized) {
27634 throw new Error("initializeWasm() must be awaited first!");
27636 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
27637 // debug statements here
27639 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27641 export function InitFeatures_supports_channel_type(this_arg: number): boolean {
27642 if(!isWasmInitialized) {
27643 throw new Error("initializeWasm() must be awaited first!");
27645 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
27646 return nativeResponseValue;
27648 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27650 export function NodeFeatures_set_channel_type_optional(this_arg: number): void {
27651 if(!isWasmInitialized) {
27652 throw new Error("initializeWasm() must be awaited first!");
27654 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
27655 // debug statements here
27657 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27659 export function NodeFeatures_set_channel_type_required(this_arg: number): void {
27660 if(!isWasmInitialized) {
27661 throw new Error("initializeWasm() must be awaited first!");
27663 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
27664 // debug statements here
27666 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27668 export function NodeFeatures_supports_channel_type(this_arg: number): boolean {
27669 if(!isWasmInitialized) {
27670 throw new Error("initializeWasm() must be awaited first!");
27672 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
27673 return nativeResponseValue;
27675 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27677 export function InitFeatures_requires_channel_type(this_arg: number): boolean {
27678 if(!isWasmInitialized) {
27679 throw new Error("initializeWasm() must be awaited first!");
27681 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
27682 return nativeResponseValue;
27684 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27686 export function NodeFeatures_requires_channel_type(this_arg: number): boolean {
27687 if(!isWasmInitialized) {
27688 throw new Error("initializeWasm() must be awaited first!");
27690 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
27691 return nativeResponseValue;
27693 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27695 export function InitFeatures_set_scid_privacy_optional(this_arg: number): void {
27696 if(!isWasmInitialized) {
27697 throw new Error("initializeWasm() must be awaited first!");
27699 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
27700 // debug statements here
27702 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27704 export function InitFeatures_set_scid_privacy_required(this_arg: number): void {
27705 if(!isWasmInitialized) {
27706 throw new Error("initializeWasm() must be awaited first!");
27708 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
27709 // debug statements here
27711 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27713 export function InitFeatures_supports_scid_privacy(this_arg: number): boolean {
27714 if(!isWasmInitialized) {
27715 throw new Error("initializeWasm() must be awaited first!");
27717 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
27718 return nativeResponseValue;
27720 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27722 export function NodeFeatures_set_scid_privacy_optional(this_arg: number): void {
27723 if(!isWasmInitialized) {
27724 throw new Error("initializeWasm() must be awaited first!");
27726 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
27727 // debug statements here
27729 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27731 export function NodeFeatures_set_scid_privacy_required(this_arg: number): void {
27732 if(!isWasmInitialized) {
27733 throw new Error("initializeWasm() must be awaited first!");
27735 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
27736 // debug statements here
27738 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27740 export function NodeFeatures_supports_scid_privacy(this_arg: number): boolean {
27741 if(!isWasmInitialized) {
27742 throw new Error("initializeWasm() must be awaited first!");
27744 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
27745 return nativeResponseValue;
27747 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27749 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: number): void {
27750 if(!isWasmInitialized) {
27751 throw new Error("initializeWasm() must be awaited first!");
27753 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
27754 // debug statements here
27756 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27758 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: number): void {
27759 if(!isWasmInitialized) {
27760 throw new Error("initializeWasm() must be awaited first!");
27762 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
27763 // debug statements here
27765 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27767 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: number): boolean {
27768 if(!isWasmInitialized) {
27769 throw new Error("initializeWasm() must be awaited first!");
27771 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
27772 return nativeResponseValue;
27774 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27776 export function InitFeatures_requires_scid_privacy(this_arg: number): boolean {
27777 if(!isWasmInitialized) {
27778 throw new Error("initializeWasm() must be awaited first!");
27780 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
27781 return nativeResponseValue;
27783 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27785 export function NodeFeatures_requires_scid_privacy(this_arg: number): boolean {
27786 if(!isWasmInitialized) {
27787 throw new Error("initializeWasm() must be awaited first!");
27789 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
27790 return nativeResponseValue;
27792 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27794 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: number): boolean {
27795 if(!isWasmInitialized) {
27796 throw new Error("initializeWasm() must be awaited first!");
27798 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
27799 return nativeResponseValue;
27801 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27803 export function InitFeatures_set_zero_conf_optional(this_arg: number): void {
27804 if(!isWasmInitialized) {
27805 throw new Error("initializeWasm() must be awaited first!");
27807 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
27808 // debug statements here
27810 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27812 export function InitFeatures_set_zero_conf_required(this_arg: number): void {
27813 if(!isWasmInitialized) {
27814 throw new Error("initializeWasm() must be awaited first!");
27816 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
27817 // debug statements here
27819 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27821 export function InitFeatures_supports_zero_conf(this_arg: number): boolean {
27822 if(!isWasmInitialized) {
27823 throw new Error("initializeWasm() must be awaited first!");
27825 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
27826 return nativeResponseValue;
27828 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27830 export function NodeFeatures_set_zero_conf_optional(this_arg: number): void {
27831 if(!isWasmInitialized) {
27832 throw new Error("initializeWasm() must be awaited first!");
27834 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
27835 // debug statements here
27837 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27839 export function NodeFeatures_set_zero_conf_required(this_arg: number): void {
27840 if(!isWasmInitialized) {
27841 throw new Error("initializeWasm() must be awaited first!");
27843 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
27844 // debug statements here
27846 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27848 export function NodeFeatures_supports_zero_conf(this_arg: number): boolean {
27849 if(!isWasmInitialized) {
27850 throw new Error("initializeWasm() must be awaited first!");
27852 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
27853 return nativeResponseValue;
27855 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27857 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: number): void {
27858 if(!isWasmInitialized) {
27859 throw new Error("initializeWasm() must be awaited first!");
27861 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
27862 // debug statements here
27864 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27866 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: number): void {
27867 if(!isWasmInitialized) {
27868 throw new Error("initializeWasm() must be awaited first!");
27870 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
27871 // debug statements here
27873 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27875 export function ChannelTypeFeatures_supports_zero_conf(this_arg: number): boolean {
27876 if(!isWasmInitialized) {
27877 throw new Error("initializeWasm() must be awaited first!");
27879 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
27880 return nativeResponseValue;
27882 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27884 export function InitFeatures_requires_zero_conf(this_arg: number): boolean {
27885 if(!isWasmInitialized) {
27886 throw new Error("initializeWasm() must be awaited first!");
27888 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
27889 return nativeResponseValue;
27891 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27893 export function NodeFeatures_requires_zero_conf(this_arg: number): boolean {
27894 if(!isWasmInitialized) {
27895 throw new Error("initializeWasm() must be awaited first!");
27897 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
27898 return nativeResponseValue;
27900 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27902 export function ChannelTypeFeatures_requires_zero_conf(this_arg: number): boolean {
27903 if(!isWasmInitialized) {
27904 throw new Error("initializeWasm() must be awaited first!");
27906 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
27907 return nativeResponseValue;
27909 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27911 export function NodeFeatures_set_keysend_optional(this_arg: number): void {
27912 if(!isWasmInitialized) {
27913 throw new Error("initializeWasm() must be awaited first!");
27915 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
27916 // debug statements here
27918 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27920 export function NodeFeatures_set_keysend_required(this_arg: number): void {
27921 if(!isWasmInitialized) {
27922 throw new Error("initializeWasm() must be awaited first!");
27924 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
27925 // debug statements here
27927 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27929 export function NodeFeatures_supports_keysend(this_arg: number): boolean {
27930 if(!isWasmInitialized) {
27931 throw new Error("initializeWasm() must be awaited first!");
27933 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
27934 return nativeResponseValue;
27936 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27938 export function NodeFeatures_requires_keysend(this_arg: number): boolean {
27939 if(!isWasmInitialized) {
27940 throw new Error("initializeWasm() must be awaited first!");
27942 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
27943 return nativeResponseValue;
27945 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
27947 export function ShutdownScript_free(this_obj: number): void {
27948 if(!isWasmInitialized) {
27949 throw new Error("initializeWasm() must be awaited first!");
27951 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
27952 // debug statements here
27954 // uintptr_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
27956 export function ShutdownScript_clone_ptr(arg: number): number {
27957 if(!isWasmInitialized) {
27958 throw new Error("initializeWasm() must be awaited first!");
27960 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
27961 return nativeResponseValue;
27963 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
27965 export function ShutdownScript_clone(orig: number): number {
27966 if(!isWasmInitialized) {
27967 throw new Error("initializeWasm() must be awaited first!");
27969 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
27970 return nativeResponseValue;
27972 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
27974 export function InvalidShutdownScript_free(this_obj: number): void {
27975 if(!isWasmInitialized) {
27976 throw new Error("initializeWasm() must be awaited first!");
27978 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
27979 // debug statements here
27981 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
27983 export function InvalidShutdownScript_get_script(this_ptr: number): number {
27984 if(!isWasmInitialized) {
27985 throw new Error("initializeWasm() must be awaited first!");
27987 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
27988 return nativeResponseValue;
27990 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
27992 export function InvalidShutdownScript_set_script(this_ptr: number, val: number): void {
27993 if(!isWasmInitialized) {
27994 throw new Error("initializeWasm() must be awaited first!");
27996 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
27997 // debug statements here
27999 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
28001 export function InvalidShutdownScript_new(script_arg: number): number {
28002 if(!isWasmInitialized) {
28003 throw new Error("initializeWasm() must be awaited first!");
28005 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
28006 return nativeResponseValue;
28008 // uintptr_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
28010 export function InvalidShutdownScript_clone_ptr(arg: number): number {
28011 if(!isWasmInitialized) {
28012 throw new Error("initializeWasm() must be awaited first!");
28014 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
28015 return nativeResponseValue;
28017 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
28019 export function InvalidShutdownScript_clone(orig: number): number {
28020 if(!isWasmInitialized) {
28021 throw new Error("initializeWasm() must be awaited first!");
28023 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
28024 return nativeResponseValue;
28026 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
28028 export function ShutdownScript_write(obj: number): number {
28029 if(!isWasmInitialized) {
28030 throw new Error("initializeWasm() must be awaited first!");
28032 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
28033 return nativeResponseValue;
28035 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
28037 export function ShutdownScript_read(ser: number): number {
28038 if(!isWasmInitialized) {
28039 throw new Error("initializeWasm() must be awaited first!");
28041 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
28042 return nativeResponseValue;
28044 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
28046 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): number {
28047 if(!isWasmInitialized) {
28048 throw new Error("initializeWasm() must be awaited first!");
28050 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
28051 return nativeResponseValue;
28053 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
28055 export function ShutdownScript_new_p2wsh(script_hash: number): number {
28056 if(!isWasmInitialized) {
28057 throw new Error("initializeWasm() must be awaited first!");
28059 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
28060 return nativeResponseValue;
28062 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
28064 export function ShutdownScript_new_witness_program(version: number, program: number): number {
28065 if(!isWasmInitialized) {
28066 throw new Error("initializeWasm() must be awaited first!");
28068 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
28069 return nativeResponseValue;
28071 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
28073 export function ShutdownScript_into_inner(this_arg: number): number {
28074 if(!isWasmInitialized) {
28075 throw new Error("initializeWasm() must be awaited first!");
28077 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
28078 return nativeResponseValue;
28080 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
28082 export function ShutdownScript_as_legacy_pubkey(this_arg: number): number {
28083 if(!isWasmInitialized) {
28084 throw new Error("initializeWasm() must be awaited first!");
28086 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
28087 return nativeResponseValue;
28089 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
28091 export function ShutdownScript_is_compatible(this_arg: number, features: number): boolean {
28092 if(!isWasmInitialized) {
28093 throw new Error("initializeWasm() must be awaited first!");
28095 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
28096 return nativeResponseValue;
28098 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
28100 export function CustomMessageReader_free(this_ptr: number): void {
28101 if(!isWasmInitialized) {
28102 throw new Error("initializeWasm() must be awaited first!");
28104 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
28105 // debug statements here
28107 // uintptr_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
28109 export function Type_clone_ptr(arg: number): number {
28110 if(!isWasmInitialized) {
28111 throw new Error("initializeWasm() must be awaited first!");
28113 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
28114 return nativeResponseValue;
28116 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
28118 export function Type_clone(orig: number): number {
28119 if(!isWasmInitialized) {
28120 throw new Error("initializeWasm() must be awaited first!");
28122 const nativeResponseValue = wasm.TS_Type_clone(orig);
28123 return nativeResponseValue;
28125 // void Type_free(struct LDKType this_ptr);
28127 export function Type_free(this_ptr: number): void {
28128 if(!isWasmInitialized) {
28129 throw new Error("initializeWasm() must be awaited first!");
28131 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
28132 // debug statements here
28134 // void NodeId_free(struct LDKNodeId this_obj);
28136 export function NodeId_free(this_obj: number): void {
28137 if(!isWasmInitialized) {
28138 throw new Error("initializeWasm() must be awaited first!");
28140 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
28141 // debug statements here
28143 // uintptr_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
28145 export function NodeId_clone_ptr(arg: number): number {
28146 if(!isWasmInitialized) {
28147 throw new Error("initializeWasm() must be awaited first!");
28149 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
28150 return nativeResponseValue;
28152 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
28154 export function NodeId_clone(orig: number): number {
28155 if(!isWasmInitialized) {
28156 throw new Error("initializeWasm() must be awaited first!");
28158 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
28159 return nativeResponseValue;
28161 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
28163 export function NodeId_from_pubkey(pubkey: number): number {
28164 if(!isWasmInitialized) {
28165 throw new Error("initializeWasm() must be awaited first!");
28167 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
28168 return nativeResponseValue;
28170 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
28172 export function NodeId_as_slice(this_arg: number): number {
28173 if(!isWasmInitialized) {
28174 throw new Error("initializeWasm() must be awaited first!");
28176 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
28177 return nativeResponseValue;
28179 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
28181 export function NodeId_hash(o: number): bigint {
28182 if(!isWasmInitialized) {
28183 throw new Error("initializeWasm() must be awaited first!");
28185 const nativeResponseValue = wasm.TS_NodeId_hash(o);
28186 return nativeResponseValue;
28188 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
28190 export function NodeId_write(obj: number): number {
28191 if(!isWasmInitialized) {
28192 throw new Error("initializeWasm() must be awaited first!");
28194 const nativeResponseValue = wasm.TS_NodeId_write(obj);
28195 return nativeResponseValue;
28197 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
28199 export function NodeId_read(ser: number): number {
28200 if(!isWasmInitialized) {
28201 throw new Error("initializeWasm() must be awaited first!");
28203 const nativeResponseValue = wasm.TS_NodeId_read(ser);
28204 return nativeResponseValue;
28206 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
28208 export function NetworkGraph_free(this_obj: number): void {
28209 if(!isWasmInitialized) {
28210 throw new Error("initializeWasm() must be awaited first!");
28212 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
28213 // debug statements here
28215 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
28217 export function ReadOnlyNetworkGraph_free(this_obj: number): void {
28218 if(!isWasmInitialized) {
28219 throw new Error("initializeWasm() must be awaited first!");
28221 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
28222 // debug statements here
28224 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
28226 export function NetworkUpdate_free(this_ptr: number): void {
28227 if(!isWasmInitialized) {
28228 throw new Error("initializeWasm() must be awaited first!");
28230 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
28231 // debug statements here
28233 // uintptr_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
28235 export function NetworkUpdate_clone_ptr(arg: number): number {
28236 if(!isWasmInitialized) {
28237 throw new Error("initializeWasm() must be awaited first!");
28239 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
28240 return nativeResponseValue;
28242 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
28244 export function NetworkUpdate_clone(orig: number): number {
28245 if(!isWasmInitialized) {
28246 throw new Error("initializeWasm() must be awaited first!");
28248 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
28249 return nativeResponseValue;
28251 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
28253 export function NetworkUpdate_channel_update_message(msg: number): number {
28254 if(!isWasmInitialized) {
28255 throw new Error("initializeWasm() must be awaited first!");
28257 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
28258 return nativeResponseValue;
28260 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
28262 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): number {
28263 if(!isWasmInitialized) {
28264 throw new Error("initializeWasm() must be awaited first!");
28266 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
28267 return nativeResponseValue;
28269 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
28271 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): number {
28272 if(!isWasmInitialized) {
28273 throw new Error("initializeWasm() must be awaited first!");
28275 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
28276 return nativeResponseValue;
28278 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
28280 export function NetworkUpdate_write(obj: number): number {
28281 if(!isWasmInitialized) {
28282 throw new Error("initializeWasm() must be awaited first!");
28284 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
28285 return nativeResponseValue;
28287 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
28289 export function NetworkUpdate_read(ser: number): number {
28290 if(!isWasmInitialized) {
28291 throw new Error("initializeWasm() must be awaited first!");
28293 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
28294 return nativeResponseValue;
28296 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
28298 export function P2PGossipSync_free(this_obj: number): void {
28299 if(!isWasmInitialized) {
28300 throw new Error("initializeWasm() must be awaited first!");
28302 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
28303 // debug statements here
28305 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
28307 export function P2PGossipSync_new(network_graph: number, chain_access: number, logger: number): number {
28308 if(!isWasmInitialized) {
28309 throw new Error("initializeWasm() must be awaited first!");
28311 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, chain_access, logger);
28312 return nativeResponseValue;
28314 // void P2PGossipSync_add_chain_access(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
28316 export function P2PGossipSync_add_chain_access(this_arg: number, chain_access: number): void {
28317 if(!isWasmInitialized) {
28318 throw new Error("initializeWasm() must be awaited first!");
28320 const nativeResponseValue = wasm.TS_P2PGossipSync_add_chain_access(this_arg, chain_access);
28321 // debug statements here
28323 // struct LDKEventHandler NetworkGraph_as_EventHandler(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
28325 export function NetworkGraph_as_EventHandler(this_arg: number): number {
28326 if(!isWasmInitialized) {
28327 throw new Error("initializeWasm() must be awaited first!");
28329 const nativeResponseValue = wasm.TS_NetworkGraph_as_EventHandler(this_arg);
28330 return nativeResponseValue;
28332 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
28334 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: number): number {
28335 if(!isWasmInitialized) {
28336 throw new Error("initializeWasm() must be awaited first!");
28338 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
28339 return nativeResponseValue;
28341 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
28343 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: number): number {
28344 if(!isWasmInitialized) {
28345 throw new Error("initializeWasm() must be awaited first!");
28347 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
28348 return nativeResponseValue;
28350 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
28352 export function ChannelUpdateInfo_free(this_obj: number): void {
28353 if(!isWasmInitialized) {
28354 throw new Error("initializeWasm() must be awaited first!");
28356 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
28357 // debug statements here
28359 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28361 export function ChannelUpdateInfo_get_last_update(this_ptr: number): number {
28362 if(!isWasmInitialized) {
28363 throw new Error("initializeWasm() must be awaited first!");
28365 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
28366 return nativeResponseValue;
28368 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
28370 export function ChannelUpdateInfo_set_last_update(this_ptr: number, val: number): void {
28371 if(!isWasmInitialized) {
28372 throw new Error("initializeWasm() must be awaited first!");
28374 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
28375 // debug statements here
28377 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28379 export function ChannelUpdateInfo_get_enabled(this_ptr: number): boolean {
28380 if(!isWasmInitialized) {
28381 throw new Error("initializeWasm() must be awaited first!");
28383 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
28384 return nativeResponseValue;
28386 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
28388 export function ChannelUpdateInfo_set_enabled(this_ptr: number, val: boolean): void {
28389 if(!isWasmInitialized) {
28390 throw new Error("initializeWasm() must be awaited first!");
28392 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
28393 // debug statements here
28395 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28397 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: number): number {
28398 if(!isWasmInitialized) {
28399 throw new Error("initializeWasm() must be awaited first!");
28401 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
28402 return nativeResponseValue;
28404 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
28406 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
28407 if(!isWasmInitialized) {
28408 throw new Error("initializeWasm() must be awaited first!");
28410 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
28411 // debug statements here
28413 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28415 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: number): bigint {
28416 if(!isWasmInitialized) {
28417 throw new Error("initializeWasm() must be awaited first!");
28419 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
28420 return nativeResponseValue;
28422 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
28424 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
28425 if(!isWasmInitialized) {
28426 throw new Error("initializeWasm() must be awaited first!");
28428 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
28429 // debug statements here
28431 // struct LDKCOption_u64Z ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28433 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: number): number {
28434 if(!isWasmInitialized) {
28435 throw new Error("initializeWasm() must be awaited first!");
28437 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
28438 return nativeResponseValue;
28440 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28442 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: number, val: number): void {
28443 if(!isWasmInitialized) {
28444 throw new Error("initializeWasm() must be awaited first!");
28446 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
28447 // debug statements here
28449 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28451 export function ChannelUpdateInfo_get_fees(this_ptr: number): number {
28452 if(!isWasmInitialized) {
28453 throw new Error("initializeWasm() must be awaited first!");
28455 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
28456 return nativeResponseValue;
28458 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
28460 export function ChannelUpdateInfo_set_fees(this_ptr: number, val: number): void {
28461 if(!isWasmInitialized) {
28462 throw new Error("initializeWasm() must be awaited first!");
28464 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
28465 // debug statements here
28467 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28469 export function ChannelUpdateInfo_get_last_update_message(this_ptr: number): number {
28470 if(!isWasmInitialized) {
28471 throw new Error("initializeWasm() must be awaited first!");
28473 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
28474 return nativeResponseValue;
28476 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
28478 export function ChannelUpdateInfo_set_last_update_message(this_ptr: number, val: number): void {
28479 if(!isWasmInitialized) {
28480 throw new Error("initializeWasm() must be awaited first!");
28482 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
28483 // debug statements here
28485 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelUpdateInfo_new(uint32_t last_update_arg, bool enabled_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, struct LDKCOption_u64Z htlc_maximum_msat_arg, struct LDKRoutingFees fees_arg, struct LDKChannelUpdate last_update_message_arg);
28487 export function ChannelUpdateInfo_new(last_update_arg: number, enabled_arg: boolean, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: bigint, htlc_maximum_msat_arg: number, fees_arg: number, last_update_message_arg: number): number {
28488 if(!isWasmInitialized) {
28489 throw new Error("initializeWasm() must be awaited first!");
28491 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);
28492 return nativeResponseValue;
28494 // uintptr_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
28496 export function ChannelUpdateInfo_clone_ptr(arg: number): number {
28497 if(!isWasmInitialized) {
28498 throw new Error("initializeWasm() must be awaited first!");
28500 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
28501 return nativeResponseValue;
28503 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
28505 export function ChannelUpdateInfo_clone(orig: number): number {
28506 if(!isWasmInitialized) {
28507 throw new Error("initializeWasm() must be awaited first!");
28509 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
28510 return nativeResponseValue;
28512 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
28514 export function ChannelUpdateInfo_write(obj: number): number {
28515 if(!isWasmInitialized) {
28516 throw new Error("initializeWasm() must be awaited first!");
28518 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
28519 return nativeResponseValue;
28521 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
28523 export function ChannelUpdateInfo_read(ser: number): number {
28524 if(!isWasmInitialized) {
28525 throw new Error("initializeWasm() must be awaited first!");
28527 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
28528 return nativeResponseValue;
28530 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
28532 export function ChannelInfo_free(this_obj: number): void {
28533 if(!isWasmInitialized) {
28534 throw new Error("initializeWasm() must be awaited first!");
28536 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
28537 // debug statements here
28539 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28541 export function ChannelInfo_get_features(this_ptr: number): number {
28542 if(!isWasmInitialized) {
28543 throw new Error("initializeWasm() must be awaited first!");
28545 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
28546 return nativeResponseValue;
28548 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
28550 export function ChannelInfo_set_features(this_ptr: number, val: number): void {
28551 if(!isWasmInitialized) {
28552 throw new Error("initializeWasm() must be awaited first!");
28554 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
28555 // debug statements here
28557 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28559 export function ChannelInfo_get_node_one(this_ptr: number): number {
28560 if(!isWasmInitialized) {
28561 throw new Error("initializeWasm() must be awaited first!");
28563 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
28564 return nativeResponseValue;
28566 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
28568 export function ChannelInfo_set_node_one(this_ptr: number, val: number): void {
28569 if(!isWasmInitialized) {
28570 throw new Error("initializeWasm() must be awaited first!");
28572 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
28573 // debug statements here
28575 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28577 export function ChannelInfo_get_one_to_two(this_ptr: number): number {
28578 if(!isWasmInitialized) {
28579 throw new Error("initializeWasm() must be awaited first!");
28581 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
28582 return nativeResponseValue;
28584 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
28586 export function ChannelInfo_set_one_to_two(this_ptr: number, val: number): void {
28587 if(!isWasmInitialized) {
28588 throw new Error("initializeWasm() must be awaited first!");
28590 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
28591 // debug statements here
28593 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28595 export function ChannelInfo_get_node_two(this_ptr: number): number {
28596 if(!isWasmInitialized) {
28597 throw new Error("initializeWasm() must be awaited first!");
28599 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
28600 return nativeResponseValue;
28602 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
28604 export function ChannelInfo_set_node_two(this_ptr: number, val: number): void {
28605 if(!isWasmInitialized) {
28606 throw new Error("initializeWasm() must be awaited first!");
28608 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
28609 // debug statements here
28611 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28613 export function ChannelInfo_get_two_to_one(this_ptr: number): number {
28614 if(!isWasmInitialized) {
28615 throw new Error("initializeWasm() must be awaited first!");
28617 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
28618 return nativeResponseValue;
28620 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
28622 export function ChannelInfo_set_two_to_one(this_ptr: number, val: number): void {
28623 if(!isWasmInitialized) {
28624 throw new Error("initializeWasm() must be awaited first!");
28626 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
28627 // debug statements here
28629 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28631 export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
28632 if(!isWasmInitialized) {
28633 throw new Error("initializeWasm() must be awaited first!");
28635 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
28636 return nativeResponseValue;
28638 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28640 export function ChannelInfo_set_capacity_sats(this_ptr: number, val: number): void {
28641 if(!isWasmInitialized) {
28642 throw new Error("initializeWasm() must be awaited first!");
28644 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
28645 // debug statements here
28647 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28649 export function ChannelInfo_get_announcement_message(this_ptr: number): number {
28650 if(!isWasmInitialized) {
28651 throw new Error("initializeWasm() must be awaited first!");
28653 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
28654 return nativeResponseValue;
28656 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
28658 export function ChannelInfo_set_announcement_message(this_ptr: number, val: number): void {
28659 if(!isWasmInitialized) {
28660 throw new Error("initializeWasm() must be awaited first!");
28662 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
28663 // debug statements here
28665 // uintptr_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
28667 export function ChannelInfo_clone_ptr(arg: number): number {
28668 if(!isWasmInitialized) {
28669 throw new Error("initializeWasm() must be awaited first!");
28671 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
28672 return nativeResponseValue;
28674 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
28676 export function ChannelInfo_clone(orig: number): number {
28677 if(!isWasmInitialized) {
28678 throw new Error("initializeWasm() must be awaited first!");
28680 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
28681 return nativeResponseValue;
28683 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
28685 export function ChannelInfo_get_directional_info(this_arg: number, channel_flags: number): number {
28686 if(!isWasmInitialized) {
28687 throw new Error("initializeWasm() must be awaited first!");
28689 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
28690 return nativeResponseValue;
28692 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
28694 export function ChannelInfo_write(obj: number): number {
28695 if(!isWasmInitialized) {
28696 throw new Error("initializeWasm() must be awaited first!");
28698 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
28699 return nativeResponseValue;
28701 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
28703 export function ChannelInfo_read(ser: number): number {
28704 if(!isWasmInitialized) {
28705 throw new Error("initializeWasm() must be awaited first!");
28707 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
28708 return nativeResponseValue;
28710 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
28712 export function DirectedChannelInfo_free(this_obj: number): void {
28713 if(!isWasmInitialized) {
28714 throw new Error("initializeWasm() must be awaited first!");
28716 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
28717 // debug statements here
28719 // uintptr_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
28721 export function DirectedChannelInfo_clone_ptr(arg: number): number {
28722 if(!isWasmInitialized) {
28723 throw new Error("initializeWasm() must be awaited first!");
28725 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
28726 return nativeResponseValue;
28728 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
28730 export function DirectedChannelInfo_clone(orig: number): number {
28731 if(!isWasmInitialized) {
28732 throw new Error("initializeWasm() must be awaited first!");
28734 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
28735 return nativeResponseValue;
28737 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
28739 export function DirectedChannelInfo_channel(this_arg: number): number {
28740 if(!isWasmInitialized) {
28741 throw new Error("initializeWasm() must be awaited first!");
28743 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
28744 return nativeResponseValue;
28746 // MUST_USE_RES struct LDKChannelUpdateInfo DirectedChannelInfo_direction(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
28748 export function DirectedChannelInfo_direction(this_arg: number): number {
28749 if(!isWasmInitialized) {
28750 throw new Error("initializeWasm() must be awaited first!");
28752 const nativeResponseValue = wasm.TS_DirectedChannelInfo_direction(this_arg);
28753 return nativeResponseValue;
28755 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
28757 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: number): bigint {
28758 if(!isWasmInitialized) {
28759 throw new Error("initializeWasm() must be awaited first!");
28761 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
28762 return nativeResponseValue;
28764 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
28766 export function DirectedChannelInfo_effective_capacity(this_arg: number): number {
28767 if(!isWasmInitialized) {
28768 throw new Error("initializeWasm() must be awaited first!");
28770 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
28771 return nativeResponseValue;
28773 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
28775 export function EffectiveCapacity_free(this_ptr: number): void {
28776 if(!isWasmInitialized) {
28777 throw new Error("initializeWasm() must be awaited first!");
28779 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
28780 // debug statements here
28782 // uintptr_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
28784 export function EffectiveCapacity_clone_ptr(arg: number): number {
28785 if(!isWasmInitialized) {
28786 throw new Error("initializeWasm() must be awaited first!");
28788 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
28789 return nativeResponseValue;
28791 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
28793 export function EffectiveCapacity_clone(orig: number): number {
28794 if(!isWasmInitialized) {
28795 throw new Error("initializeWasm() must be awaited first!");
28797 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
28798 return nativeResponseValue;
28800 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
28802 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): number {
28803 if(!isWasmInitialized) {
28804 throw new Error("initializeWasm() must be awaited first!");
28806 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
28807 return nativeResponseValue;
28809 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
28811 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): number {
28812 if(!isWasmInitialized) {
28813 throw new Error("initializeWasm() must be awaited first!");
28815 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
28816 return nativeResponseValue;
28818 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat);
28820 export function EffectiveCapacity_total(capacity_msat: bigint): number {
28821 if(!isWasmInitialized) {
28822 throw new Error("initializeWasm() must be awaited first!");
28824 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat);
28825 return nativeResponseValue;
28827 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
28829 export function EffectiveCapacity_infinite(): number {
28830 if(!isWasmInitialized) {
28831 throw new Error("initializeWasm() must be awaited first!");
28833 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
28834 return nativeResponseValue;
28836 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
28838 export function EffectiveCapacity_unknown(): number {
28839 if(!isWasmInitialized) {
28840 throw new Error("initializeWasm() must be awaited first!");
28842 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
28843 return nativeResponseValue;
28845 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
28847 export function EffectiveCapacity_as_msat(this_arg: number): bigint {
28848 if(!isWasmInitialized) {
28849 throw new Error("initializeWasm() must be awaited first!");
28851 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
28852 return nativeResponseValue;
28854 // void RoutingFees_free(struct LDKRoutingFees this_obj);
28856 export function RoutingFees_free(this_obj: number): void {
28857 if(!isWasmInitialized) {
28858 throw new Error("initializeWasm() must be awaited first!");
28860 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
28861 // debug statements here
28863 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
28865 export function RoutingFees_get_base_msat(this_ptr: number): number {
28866 if(!isWasmInitialized) {
28867 throw new Error("initializeWasm() must be awaited first!");
28869 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
28870 return nativeResponseValue;
28872 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
28874 export function RoutingFees_set_base_msat(this_ptr: number, val: number): void {
28875 if(!isWasmInitialized) {
28876 throw new Error("initializeWasm() must be awaited first!");
28878 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
28879 // debug statements here
28881 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
28883 export function RoutingFees_get_proportional_millionths(this_ptr: number): number {
28884 if(!isWasmInitialized) {
28885 throw new Error("initializeWasm() must be awaited first!");
28887 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
28888 return nativeResponseValue;
28890 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
28892 export function RoutingFees_set_proportional_millionths(this_ptr: number, val: number): void {
28893 if(!isWasmInitialized) {
28894 throw new Error("initializeWasm() must be awaited first!");
28896 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
28897 // debug statements here
28899 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
28901 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): number {
28902 if(!isWasmInitialized) {
28903 throw new Error("initializeWasm() must be awaited first!");
28905 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
28906 return nativeResponseValue;
28908 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
28910 export function RoutingFees_eq(a: number, b: number): boolean {
28911 if(!isWasmInitialized) {
28912 throw new Error("initializeWasm() must be awaited first!");
28914 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
28915 return nativeResponseValue;
28917 // uintptr_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
28919 export function RoutingFees_clone_ptr(arg: number): number {
28920 if(!isWasmInitialized) {
28921 throw new Error("initializeWasm() must be awaited first!");
28923 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
28924 return nativeResponseValue;
28926 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
28928 export function RoutingFees_clone(orig: number): number {
28929 if(!isWasmInitialized) {
28930 throw new Error("initializeWasm() must be awaited first!");
28932 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
28933 return nativeResponseValue;
28935 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
28937 export function RoutingFees_hash(o: number): bigint {
28938 if(!isWasmInitialized) {
28939 throw new Error("initializeWasm() must be awaited first!");
28941 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
28942 return nativeResponseValue;
28944 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
28946 export function RoutingFees_write(obj: number): number {
28947 if(!isWasmInitialized) {
28948 throw new Error("initializeWasm() must be awaited first!");
28950 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
28951 return nativeResponseValue;
28953 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
28955 export function RoutingFees_read(ser: number): number {
28956 if(!isWasmInitialized) {
28957 throw new Error("initializeWasm() must be awaited first!");
28959 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
28960 return nativeResponseValue;
28962 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
28964 export function NodeAnnouncementInfo_free(this_obj: number): void {
28965 if(!isWasmInitialized) {
28966 throw new Error("initializeWasm() must be awaited first!");
28968 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
28969 // debug statements here
28971 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
28973 export function NodeAnnouncementInfo_get_features(this_ptr: number): number {
28974 if(!isWasmInitialized) {
28975 throw new Error("initializeWasm() must be awaited first!");
28977 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
28978 return nativeResponseValue;
28980 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
28982 export function NodeAnnouncementInfo_set_features(this_ptr: number, val: number): void {
28983 if(!isWasmInitialized) {
28984 throw new Error("initializeWasm() must be awaited first!");
28986 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
28987 // debug statements here
28989 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
28991 export function NodeAnnouncementInfo_get_last_update(this_ptr: number): number {
28992 if(!isWasmInitialized) {
28993 throw new Error("initializeWasm() must be awaited first!");
28995 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
28996 return nativeResponseValue;
28998 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
29000 export function NodeAnnouncementInfo_set_last_update(this_ptr: number, val: number): void {
29001 if(!isWasmInitialized) {
29002 throw new Error("initializeWasm() must be awaited first!");
29004 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
29005 // debug statements here
29007 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
29009 export function NodeAnnouncementInfo_get_rgb(this_ptr: number): number {
29010 if(!isWasmInitialized) {
29011 throw new Error("initializeWasm() must be awaited first!");
29013 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
29014 return nativeResponseValue;
29016 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
29018 export function NodeAnnouncementInfo_set_rgb(this_ptr: number, val: number): void {
29019 if(!isWasmInitialized) {
29020 throw new Error("initializeWasm() must be awaited first!");
29022 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
29023 // debug statements here
29025 // const uint8_t (*NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[32];
29027 export function NodeAnnouncementInfo_get_alias(this_ptr: number): number {
29028 if(!isWasmInitialized) {
29029 throw new Error("initializeWasm() must be awaited first!");
29031 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
29032 return nativeResponseValue;
29034 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29036 export function NodeAnnouncementInfo_set_alias(this_ptr: number, val: number): void {
29037 if(!isWasmInitialized) {
29038 throw new Error("initializeWasm() must be awaited first!");
29040 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
29041 // debug statements here
29043 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
29045 export function NodeAnnouncementInfo_set_addresses(this_ptr: number, val: number): void {
29046 if(!isWasmInitialized) {
29047 throw new Error("initializeWasm() must be awaited first!");
29049 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
29050 // debug statements here
29052 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29054 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: number): number {
29055 if(!isWasmInitialized) {
29056 throw new Error("initializeWasm() must be awaited first!");
29058 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
29059 return nativeResponseValue;
29061 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
29063 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: number, val: number): void {
29064 if(!isWasmInitialized) {
29065 throw new Error("initializeWasm() must be awaited first!");
29067 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
29068 // debug statements here
29070 // MUST_USE_RES struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_new(struct LDKNodeFeatures features_arg, uint32_t last_update_arg, struct LDKThreeBytes rgb_arg, struct LDKThirtyTwoBytes alias_arg, struct LDKCVec_NetAddressZ addresses_arg, struct LDKNodeAnnouncement announcement_message_arg);
29072 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 {
29073 if(!isWasmInitialized) {
29074 throw new Error("initializeWasm() must be awaited first!");
29076 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
29077 return nativeResponseValue;
29079 // uintptr_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
29081 export function NodeAnnouncementInfo_clone_ptr(arg: number): number {
29082 if(!isWasmInitialized) {
29083 throw new Error("initializeWasm() must be awaited first!");
29085 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
29086 return nativeResponseValue;
29088 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
29090 export function NodeAnnouncementInfo_clone(orig: number): number {
29091 if(!isWasmInitialized) {
29092 throw new Error("initializeWasm() must be awaited first!");
29094 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
29095 return nativeResponseValue;
29097 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
29099 export function NodeAnnouncementInfo_write(obj: number): number {
29100 if(!isWasmInitialized) {
29101 throw new Error("initializeWasm() must be awaited first!");
29103 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
29104 return nativeResponseValue;
29106 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
29108 export function NodeAnnouncementInfo_read(ser: number): number {
29109 if(!isWasmInitialized) {
29110 throw new Error("initializeWasm() must be awaited first!");
29112 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
29113 return nativeResponseValue;
29115 // void NodeInfo_free(struct LDKNodeInfo this_obj);
29117 export function NodeInfo_free(this_obj: number): void {
29118 if(!isWasmInitialized) {
29119 throw new Error("initializeWasm() must be awaited first!");
29121 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
29122 // debug statements here
29124 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
29126 export function NodeInfo_set_channels(this_ptr: number, val: number): void {
29127 if(!isWasmInitialized) {
29128 throw new Error("initializeWasm() must be awaited first!");
29130 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
29131 // debug statements here
29133 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
29135 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: number): number {
29136 if(!isWasmInitialized) {
29137 throw new Error("initializeWasm() must be awaited first!");
29139 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
29140 return nativeResponseValue;
29142 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
29144 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: number, val: number): void {
29145 if(!isWasmInitialized) {
29146 throw new Error("initializeWasm() must be awaited first!");
29148 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
29149 // debug statements here
29151 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
29153 export function NodeInfo_get_announcement_info(this_ptr: number): number {
29154 if(!isWasmInitialized) {
29155 throw new Error("initializeWasm() must be awaited first!");
29157 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
29158 return nativeResponseValue;
29160 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
29162 export function NodeInfo_set_announcement_info(this_ptr: number, val: number): void {
29163 if(!isWasmInitialized) {
29164 throw new Error("initializeWasm() must be awaited first!");
29166 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
29167 // debug statements here
29169 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
29171 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: number, announcement_info_arg: number): number {
29172 if(!isWasmInitialized) {
29173 throw new Error("initializeWasm() must be awaited first!");
29175 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
29176 return nativeResponseValue;
29178 // uintptr_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
29180 export function NodeInfo_clone_ptr(arg: number): number {
29181 if(!isWasmInitialized) {
29182 throw new Error("initializeWasm() must be awaited first!");
29184 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
29185 return nativeResponseValue;
29187 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
29189 export function NodeInfo_clone(orig: number): number {
29190 if(!isWasmInitialized) {
29191 throw new Error("initializeWasm() must be awaited first!");
29193 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
29194 return nativeResponseValue;
29196 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
29198 export function NodeInfo_write(obj: number): number {
29199 if(!isWasmInitialized) {
29200 throw new Error("initializeWasm() must be awaited first!");
29202 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
29203 return nativeResponseValue;
29205 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
29207 export function NodeInfo_read(ser: number): number {
29208 if(!isWasmInitialized) {
29209 throw new Error("initializeWasm() must be awaited first!");
29211 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
29212 return nativeResponseValue;
29214 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
29216 export function NetworkGraph_write(obj: number): number {
29217 if(!isWasmInitialized) {
29218 throw new Error("initializeWasm() must be awaited first!");
29220 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
29221 return nativeResponseValue;
29223 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
29225 export function NetworkGraph_read(ser: number, arg: number): number {
29226 if(!isWasmInitialized) {
29227 throw new Error("initializeWasm() must be awaited first!");
29229 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
29230 return nativeResponseValue;
29232 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKLogger logger);
29234 export function NetworkGraph_new(genesis_hash: number, logger: number): number {
29235 if(!isWasmInitialized) {
29236 throw new Error("initializeWasm() must be awaited first!");
29238 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash, logger);
29239 return nativeResponseValue;
29241 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
29243 export function NetworkGraph_read_only(this_arg: number): number {
29244 if(!isWasmInitialized) {
29245 throw new Error("initializeWasm() must be awaited first!");
29247 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
29248 return nativeResponseValue;
29250 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
29252 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: number): number {
29253 if(!isWasmInitialized) {
29254 throw new Error("initializeWasm() must be awaited first!");
29256 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
29257 return nativeResponseValue;
29259 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
29261 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: number, last_rapid_gossip_sync_timestamp: number): void {
29262 if(!isWasmInitialized) {
29263 throw new Error("initializeWasm() must be awaited first!");
29265 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
29266 // debug statements here
29268 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
29270 export function NetworkGraph_update_node_from_announcement(this_arg: number, msg: number): number {
29271 if(!isWasmInitialized) {
29272 throw new Error("initializeWasm() must be awaited first!");
29274 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
29275 return nativeResponseValue;
29277 // 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);
29279 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: number, msg: number): number {
29280 if(!isWasmInitialized) {
29281 throw new Error("initializeWasm() must be awaited first!");
29283 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
29284 return nativeResponseValue;
29286 // 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);
29288 export function NetworkGraph_update_channel_from_announcement(this_arg: number, msg: number, chain_access: number): number {
29289 if(!isWasmInitialized) {
29290 throw new Error("initializeWasm() must be awaited first!");
29292 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
29293 return nativeResponseValue;
29295 // 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);
29297 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: number, msg: number, chain_access: number): number {
29298 if(!isWasmInitialized) {
29299 throw new Error("initializeWasm() must be awaited first!");
29301 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
29302 return nativeResponseValue;
29304 // 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);
29306 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 {
29307 if(!isWasmInitialized) {
29308 throw new Error("initializeWasm() must be awaited first!");
29310 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
29311 return nativeResponseValue;
29313 // void NetworkGraph_channel_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
29315 export function NetworkGraph_channel_failed(this_arg: number, short_channel_id: bigint, is_permanent: boolean): void {
29316 if(!isWasmInitialized) {
29317 throw new Error("initializeWasm() must be awaited first!");
29319 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed(this_arg, short_channel_id, is_permanent);
29320 // debug statements here
29322 // void NetworkGraph_node_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
29324 export function NetworkGraph_node_failed(this_arg: number, _node_id: number, is_permanent: boolean): void {
29325 if(!isWasmInitialized) {
29326 throw new Error("initializeWasm() must be awaited first!");
29328 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed(this_arg, _node_id, is_permanent);
29329 // debug statements here
29331 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
29333 export function NetworkGraph_remove_stale_channels_with_time(this_arg: number, current_time_unix: bigint): void {
29334 if(!isWasmInitialized) {
29335 throw new Error("initializeWasm() must be awaited first!");
29337 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
29338 // debug statements here
29340 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
29342 export function NetworkGraph_update_channel(this_arg: number, msg: number): number {
29343 if(!isWasmInitialized) {
29344 throw new Error("initializeWasm() must be awaited first!");
29346 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
29347 return nativeResponseValue;
29349 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
29351 export function NetworkGraph_update_channel_unsigned(this_arg: number, msg: number): number {
29352 if(!isWasmInitialized) {
29353 throw new Error("initializeWasm() must be awaited first!");
29355 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
29356 return nativeResponseValue;
29358 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
29360 export function ReadOnlyNetworkGraph_get_addresses(this_arg: number, pubkey: number): number {
29361 if(!isWasmInitialized) {
29362 throw new Error("initializeWasm() must be awaited first!");
29364 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
29365 return nativeResponseValue;
29367 // void RouteHop_free(struct LDKRouteHop this_obj);
29369 export function RouteHop_free(this_obj: number): void {
29370 if(!isWasmInitialized) {
29371 throw new Error("initializeWasm() must be awaited first!");
29373 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
29374 // debug statements here
29376 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29378 export function RouteHop_get_pubkey(this_ptr: number): number {
29379 if(!isWasmInitialized) {
29380 throw new Error("initializeWasm() must be awaited first!");
29382 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
29383 return nativeResponseValue;
29385 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29387 export function RouteHop_set_pubkey(this_ptr: number, val: number): void {
29388 if(!isWasmInitialized) {
29389 throw new Error("initializeWasm() must be awaited first!");
29391 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
29392 // debug statements here
29394 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29396 export function RouteHop_get_node_features(this_ptr: number): number {
29397 if(!isWasmInitialized) {
29398 throw new Error("initializeWasm() must be awaited first!");
29400 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
29401 return nativeResponseValue;
29403 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
29405 export function RouteHop_set_node_features(this_ptr: number, val: number): void {
29406 if(!isWasmInitialized) {
29407 throw new Error("initializeWasm() must be awaited first!");
29409 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
29410 // debug statements here
29412 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29414 export function RouteHop_get_short_channel_id(this_ptr: number): bigint {
29415 if(!isWasmInitialized) {
29416 throw new Error("initializeWasm() must be awaited first!");
29418 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
29419 return nativeResponseValue;
29421 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
29423 export function RouteHop_set_short_channel_id(this_ptr: number, val: bigint): void {
29424 if(!isWasmInitialized) {
29425 throw new Error("initializeWasm() must be awaited first!");
29427 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
29428 // debug statements here
29430 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29432 export function RouteHop_get_channel_features(this_ptr: number): number {
29433 if(!isWasmInitialized) {
29434 throw new Error("initializeWasm() must be awaited first!");
29436 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
29437 return nativeResponseValue;
29439 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
29441 export function RouteHop_set_channel_features(this_ptr: number, val: number): void {
29442 if(!isWasmInitialized) {
29443 throw new Error("initializeWasm() must be awaited first!");
29445 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
29446 // debug statements here
29448 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29450 export function RouteHop_get_fee_msat(this_ptr: number): bigint {
29451 if(!isWasmInitialized) {
29452 throw new Error("initializeWasm() must be awaited first!");
29454 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
29455 return nativeResponseValue;
29457 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
29459 export function RouteHop_set_fee_msat(this_ptr: number, val: bigint): void {
29460 if(!isWasmInitialized) {
29461 throw new Error("initializeWasm() must be awaited first!");
29463 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
29464 // debug statements here
29466 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29468 export function RouteHop_get_cltv_expiry_delta(this_ptr: number): number {
29469 if(!isWasmInitialized) {
29470 throw new Error("initializeWasm() must be awaited first!");
29472 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
29473 return nativeResponseValue;
29475 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
29477 export function RouteHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
29478 if(!isWasmInitialized) {
29479 throw new Error("initializeWasm() must be awaited first!");
29481 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
29482 // debug statements here
29484 // 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);
29486 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 {
29487 if(!isWasmInitialized) {
29488 throw new Error("initializeWasm() must be awaited first!");
29490 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);
29491 return nativeResponseValue;
29493 // uintptr_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
29495 export function RouteHop_clone_ptr(arg: number): number {
29496 if(!isWasmInitialized) {
29497 throw new Error("initializeWasm() must be awaited first!");
29499 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
29500 return nativeResponseValue;
29502 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
29504 export function RouteHop_clone(orig: number): number {
29505 if(!isWasmInitialized) {
29506 throw new Error("initializeWasm() must be awaited first!");
29508 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
29509 return nativeResponseValue;
29511 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
29513 export function RouteHop_hash(o: number): bigint {
29514 if(!isWasmInitialized) {
29515 throw new Error("initializeWasm() must be awaited first!");
29517 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
29518 return nativeResponseValue;
29520 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
29522 export function RouteHop_eq(a: number, b: number): boolean {
29523 if(!isWasmInitialized) {
29524 throw new Error("initializeWasm() must be awaited first!");
29526 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
29527 return nativeResponseValue;
29529 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
29531 export function RouteHop_write(obj: number): number {
29532 if(!isWasmInitialized) {
29533 throw new Error("initializeWasm() must be awaited first!");
29535 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
29536 return nativeResponseValue;
29538 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
29540 export function RouteHop_read(ser: number): number {
29541 if(!isWasmInitialized) {
29542 throw new Error("initializeWasm() must be awaited first!");
29544 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
29545 return nativeResponseValue;
29547 // void Route_free(struct LDKRoute this_obj);
29549 export function Route_free(this_obj: number): void {
29550 if(!isWasmInitialized) {
29551 throw new Error("initializeWasm() must be awaited first!");
29553 const nativeResponseValue = wasm.TS_Route_free(this_obj);
29554 // debug statements here
29556 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
29558 export function Route_get_paths(this_ptr: number): number {
29559 if(!isWasmInitialized) {
29560 throw new Error("initializeWasm() must be awaited first!");
29562 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
29563 return nativeResponseValue;
29565 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
29567 export function Route_set_paths(this_ptr: number, val: number): void {
29568 if(!isWasmInitialized) {
29569 throw new Error("initializeWasm() must be awaited first!");
29571 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
29572 // debug statements here
29574 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
29576 export function Route_get_payment_params(this_ptr: number): number {
29577 if(!isWasmInitialized) {
29578 throw new Error("initializeWasm() must be awaited first!");
29580 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
29581 return nativeResponseValue;
29583 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
29585 export function Route_set_payment_params(this_ptr: number, val: number): void {
29586 if(!isWasmInitialized) {
29587 throw new Error("initializeWasm() must be awaited first!");
29589 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
29590 // debug statements here
29592 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
29594 export function Route_new(paths_arg: number, payment_params_arg: number): number {
29595 if(!isWasmInitialized) {
29596 throw new Error("initializeWasm() must be awaited first!");
29598 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
29599 return nativeResponseValue;
29601 // uintptr_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
29603 export function Route_clone_ptr(arg: number): number {
29604 if(!isWasmInitialized) {
29605 throw new Error("initializeWasm() must be awaited first!");
29607 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
29608 return nativeResponseValue;
29610 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
29612 export function Route_clone(orig: number): number {
29613 if(!isWasmInitialized) {
29614 throw new Error("initializeWasm() must be awaited first!");
29616 const nativeResponseValue = wasm.TS_Route_clone(orig);
29617 return nativeResponseValue;
29619 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
29621 export function Route_hash(o: number): bigint {
29622 if(!isWasmInitialized) {
29623 throw new Error("initializeWasm() must be awaited first!");
29625 const nativeResponseValue = wasm.TS_Route_hash(o);
29626 return nativeResponseValue;
29628 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
29630 export function Route_eq(a: number, b: number): boolean {
29631 if(!isWasmInitialized) {
29632 throw new Error("initializeWasm() must be awaited first!");
29634 const nativeResponseValue = wasm.TS_Route_eq(a, b);
29635 return nativeResponseValue;
29637 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
29639 export function Route_get_total_fees(this_arg: number): bigint {
29640 if(!isWasmInitialized) {
29641 throw new Error("initializeWasm() must be awaited first!");
29643 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
29644 return nativeResponseValue;
29646 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
29648 export function Route_get_total_amount(this_arg: number): bigint {
29649 if(!isWasmInitialized) {
29650 throw new Error("initializeWasm() must be awaited first!");
29652 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
29653 return nativeResponseValue;
29655 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
29657 export function Route_write(obj: number): number {
29658 if(!isWasmInitialized) {
29659 throw new Error("initializeWasm() must be awaited first!");
29661 const nativeResponseValue = wasm.TS_Route_write(obj);
29662 return nativeResponseValue;
29664 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
29666 export function Route_read(ser: number): number {
29667 if(!isWasmInitialized) {
29668 throw new Error("initializeWasm() must be awaited first!");
29670 const nativeResponseValue = wasm.TS_Route_read(ser);
29671 return nativeResponseValue;
29673 // void RouteParameters_free(struct LDKRouteParameters this_obj);
29675 export function RouteParameters_free(this_obj: number): void {
29676 if(!isWasmInitialized) {
29677 throw new Error("initializeWasm() must be awaited first!");
29679 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
29680 // debug statements here
29682 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
29684 export function RouteParameters_get_payment_params(this_ptr: number): number {
29685 if(!isWasmInitialized) {
29686 throw new Error("initializeWasm() must be awaited first!");
29688 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
29689 return nativeResponseValue;
29691 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
29693 export function RouteParameters_set_payment_params(this_ptr: number, val: number): void {
29694 if(!isWasmInitialized) {
29695 throw new Error("initializeWasm() must be awaited first!");
29697 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
29698 // debug statements here
29700 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
29702 export function RouteParameters_get_final_value_msat(this_ptr: number): bigint {
29703 if(!isWasmInitialized) {
29704 throw new Error("initializeWasm() must be awaited first!");
29706 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
29707 return nativeResponseValue;
29709 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
29711 export function RouteParameters_set_final_value_msat(this_ptr: number, val: bigint): void {
29712 if(!isWasmInitialized) {
29713 throw new Error("initializeWasm() must be awaited first!");
29715 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
29716 // debug statements here
29718 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
29720 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: number): number {
29721 if(!isWasmInitialized) {
29722 throw new Error("initializeWasm() must be awaited first!");
29724 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
29725 return nativeResponseValue;
29727 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
29729 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: number, val: number): void {
29730 if(!isWasmInitialized) {
29731 throw new Error("initializeWasm() must be awaited first!");
29733 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
29734 // debug statements here
29736 // 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);
29738 export function RouteParameters_new(payment_params_arg: number, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): number {
29739 if(!isWasmInitialized) {
29740 throw new Error("initializeWasm() must be awaited first!");
29742 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
29743 return nativeResponseValue;
29745 // uintptr_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
29747 export function RouteParameters_clone_ptr(arg: number): number {
29748 if(!isWasmInitialized) {
29749 throw new Error("initializeWasm() must be awaited first!");
29751 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
29752 return nativeResponseValue;
29754 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
29756 export function RouteParameters_clone(orig: number): number {
29757 if(!isWasmInitialized) {
29758 throw new Error("initializeWasm() must be awaited first!");
29760 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
29761 return nativeResponseValue;
29763 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
29765 export function RouteParameters_write(obj: number): number {
29766 if(!isWasmInitialized) {
29767 throw new Error("initializeWasm() must be awaited first!");
29769 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
29770 return nativeResponseValue;
29772 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
29774 export function RouteParameters_read(ser: number): number {
29775 if(!isWasmInitialized) {
29776 throw new Error("initializeWasm() must be awaited first!");
29778 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
29779 return nativeResponseValue;
29781 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
29783 export function PaymentParameters_free(this_obj: number): void {
29784 if(!isWasmInitialized) {
29785 throw new Error("initializeWasm() must be awaited first!");
29787 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
29788 // debug statements here
29790 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
29792 export function PaymentParameters_get_payee_pubkey(this_ptr: number): number {
29793 if(!isWasmInitialized) {
29794 throw new Error("initializeWasm() must be awaited first!");
29796 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
29797 return nativeResponseValue;
29799 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29801 export function PaymentParameters_set_payee_pubkey(this_ptr: number, val: number): void {
29802 if(!isWasmInitialized) {
29803 throw new Error("initializeWasm() must be awaited first!");
29805 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
29806 // debug statements here
29808 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
29810 export function PaymentParameters_get_features(this_ptr: number): number {
29811 if(!isWasmInitialized) {
29812 throw new Error("initializeWasm() must be awaited first!");
29814 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
29815 return nativeResponseValue;
29817 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
29819 export function PaymentParameters_set_features(this_ptr: number, val: number): void {
29820 if(!isWasmInitialized) {
29821 throw new Error("initializeWasm() must be awaited first!");
29823 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
29824 // debug statements here
29826 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
29828 export function PaymentParameters_get_route_hints(this_ptr: number): number {
29829 if(!isWasmInitialized) {
29830 throw new Error("initializeWasm() must be awaited first!");
29832 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
29833 return nativeResponseValue;
29835 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
29837 export function PaymentParameters_set_route_hints(this_ptr: number, val: number): void {
29838 if(!isWasmInitialized) {
29839 throw new Error("initializeWasm() must be awaited first!");
29841 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
29842 // debug statements here
29844 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
29846 export function PaymentParameters_get_expiry_time(this_ptr: number): number {
29847 if(!isWasmInitialized) {
29848 throw new Error("initializeWasm() must be awaited first!");
29850 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
29851 return nativeResponseValue;
29853 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
29855 export function PaymentParameters_set_expiry_time(this_ptr: number, val: number): void {
29856 if(!isWasmInitialized) {
29857 throw new Error("initializeWasm() must be awaited first!");
29859 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
29860 // debug statements here
29862 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
29864 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: number): number {
29865 if(!isWasmInitialized) {
29866 throw new Error("initializeWasm() must be awaited first!");
29868 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
29869 return nativeResponseValue;
29871 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
29873 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: number, val: number): void {
29874 if(!isWasmInitialized) {
29875 throw new Error("initializeWasm() must be awaited first!");
29877 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
29878 // debug statements here
29880 // 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);
29882 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): number {
29883 if(!isWasmInitialized) {
29884 throw new Error("initializeWasm() must be awaited first!");
29886 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg);
29887 return nativeResponseValue;
29889 // uintptr_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
29891 export function PaymentParameters_clone_ptr(arg: number): number {
29892 if(!isWasmInitialized) {
29893 throw new Error("initializeWasm() must be awaited first!");
29895 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
29896 return nativeResponseValue;
29898 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
29900 export function PaymentParameters_clone(orig: number): number {
29901 if(!isWasmInitialized) {
29902 throw new Error("initializeWasm() must be awaited first!");
29904 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
29905 return nativeResponseValue;
29907 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
29909 export function PaymentParameters_hash(o: number): bigint {
29910 if(!isWasmInitialized) {
29911 throw new Error("initializeWasm() must be awaited first!");
29913 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
29914 return nativeResponseValue;
29916 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
29918 export function PaymentParameters_eq(a: number, b: number): boolean {
29919 if(!isWasmInitialized) {
29920 throw new Error("initializeWasm() must be awaited first!");
29922 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
29923 return nativeResponseValue;
29925 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
29927 export function PaymentParameters_write(obj: number): number {
29928 if(!isWasmInitialized) {
29929 throw new Error("initializeWasm() must be awaited first!");
29931 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
29932 return nativeResponseValue;
29934 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
29936 export function PaymentParameters_read(ser: number): number {
29937 if(!isWasmInitialized) {
29938 throw new Error("initializeWasm() must be awaited first!");
29940 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
29941 return nativeResponseValue;
29943 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
29945 export function PaymentParameters_from_node_id(payee_pubkey: number): number {
29946 if(!isWasmInitialized) {
29947 throw new Error("initializeWasm() must be awaited first!");
29949 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
29950 return nativeResponseValue;
29952 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
29954 export function PaymentParameters_for_keysend(payee_pubkey: number): number {
29955 if(!isWasmInitialized) {
29956 throw new Error("initializeWasm() must be awaited first!");
29958 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
29959 return nativeResponseValue;
29961 // void RouteHint_free(struct LDKRouteHint this_obj);
29963 export function RouteHint_free(this_obj: number): void {
29964 if(!isWasmInitialized) {
29965 throw new Error("initializeWasm() must be awaited first!");
29967 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
29968 // debug statements here
29970 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
29972 export function RouteHint_get_a(this_ptr: number): number {
29973 if(!isWasmInitialized) {
29974 throw new Error("initializeWasm() must be awaited first!");
29976 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
29977 return nativeResponseValue;
29979 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
29981 export function RouteHint_set_a(this_ptr: number, val: number): void {
29982 if(!isWasmInitialized) {
29983 throw new Error("initializeWasm() must be awaited first!");
29985 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
29986 // debug statements here
29988 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
29990 export function RouteHint_new(a_arg: number): number {
29991 if(!isWasmInitialized) {
29992 throw new Error("initializeWasm() must be awaited first!");
29994 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
29995 return nativeResponseValue;
29997 // uintptr_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
29999 export function RouteHint_clone_ptr(arg: number): number {
30000 if(!isWasmInitialized) {
30001 throw new Error("initializeWasm() must be awaited first!");
30003 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
30004 return nativeResponseValue;
30006 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
30008 export function RouteHint_clone(orig: number): number {
30009 if(!isWasmInitialized) {
30010 throw new Error("initializeWasm() must be awaited first!");
30012 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
30013 return nativeResponseValue;
30015 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
30017 export function RouteHint_hash(o: number): bigint {
30018 if(!isWasmInitialized) {
30019 throw new Error("initializeWasm() must be awaited first!");
30021 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
30022 return nativeResponseValue;
30024 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
30026 export function RouteHint_eq(a: number, b: number): boolean {
30027 if(!isWasmInitialized) {
30028 throw new Error("initializeWasm() must be awaited first!");
30030 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
30031 return nativeResponseValue;
30033 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
30035 export function RouteHint_write(obj: number): number {
30036 if(!isWasmInitialized) {
30037 throw new Error("initializeWasm() must be awaited first!");
30039 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
30040 return nativeResponseValue;
30042 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
30044 export function RouteHint_read(ser: number): number {
30045 if(!isWasmInitialized) {
30046 throw new Error("initializeWasm() must be awaited first!");
30048 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
30049 return nativeResponseValue;
30051 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
30053 export function RouteHintHop_free(this_obj: number): void {
30054 if(!isWasmInitialized) {
30055 throw new Error("initializeWasm() must be awaited first!");
30057 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
30058 // debug statements here
30060 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30062 export function RouteHintHop_get_src_node_id(this_ptr: number): number {
30063 if(!isWasmInitialized) {
30064 throw new Error("initializeWasm() must be awaited first!");
30066 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
30067 return nativeResponseValue;
30069 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30071 export function RouteHintHop_set_src_node_id(this_ptr: number, val: number): void {
30072 if(!isWasmInitialized) {
30073 throw new Error("initializeWasm() must be awaited first!");
30075 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
30076 // debug statements here
30078 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30080 export function RouteHintHop_get_short_channel_id(this_ptr: number): bigint {
30081 if(!isWasmInitialized) {
30082 throw new Error("initializeWasm() must be awaited first!");
30084 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
30085 return nativeResponseValue;
30087 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
30089 export function RouteHintHop_set_short_channel_id(this_ptr: number, val: bigint): void {
30090 if(!isWasmInitialized) {
30091 throw new Error("initializeWasm() must be awaited first!");
30093 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
30094 // debug statements here
30096 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30098 export function RouteHintHop_get_fees(this_ptr: number): number {
30099 if(!isWasmInitialized) {
30100 throw new Error("initializeWasm() must be awaited first!");
30102 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
30103 return nativeResponseValue;
30105 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
30107 export function RouteHintHop_set_fees(this_ptr: number, val: number): void {
30108 if(!isWasmInitialized) {
30109 throw new Error("initializeWasm() must be awaited first!");
30111 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
30112 // debug statements here
30114 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30116 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: number): number {
30117 if(!isWasmInitialized) {
30118 throw new Error("initializeWasm() must be awaited first!");
30120 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
30121 return nativeResponseValue;
30123 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
30125 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
30126 if(!isWasmInitialized) {
30127 throw new Error("initializeWasm() must be awaited first!");
30129 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
30130 // debug statements here
30132 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30134 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: number): number {
30135 if(!isWasmInitialized) {
30136 throw new Error("initializeWasm() must be awaited first!");
30138 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
30139 return nativeResponseValue;
30141 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30143 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: number, val: number): void {
30144 if(!isWasmInitialized) {
30145 throw new Error("initializeWasm() must be awaited first!");
30147 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
30148 // debug statements here
30150 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30152 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: number): number {
30153 if(!isWasmInitialized) {
30154 throw new Error("initializeWasm() must be awaited first!");
30156 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
30157 return nativeResponseValue;
30159 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30161 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: number, val: number): void {
30162 if(!isWasmInitialized) {
30163 throw new Error("initializeWasm() must be awaited first!");
30165 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
30166 // debug statements here
30168 // 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);
30170 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 {
30171 if(!isWasmInitialized) {
30172 throw new Error("initializeWasm() must be awaited first!");
30174 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);
30175 return nativeResponseValue;
30177 // uintptr_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
30179 export function RouteHintHop_clone_ptr(arg: number): number {
30180 if(!isWasmInitialized) {
30181 throw new Error("initializeWasm() must be awaited first!");
30183 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
30184 return nativeResponseValue;
30186 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
30188 export function RouteHintHop_clone(orig: number): number {
30189 if(!isWasmInitialized) {
30190 throw new Error("initializeWasm() must be awaited first!");
30192 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
30193 return nativeResponseValue;
30195 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
30197 export function RouteHintHop_hash(o: number): bigint {
30198 if(!isWasmInitialized) {
30199 throw new Error("initializeWasm() must be awaited first!");
30201 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
30202 return nativeResponseValue;
30204 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
30206 export function RouteHintHop_eq(a: number, b: number): boolean {
30207 if(!isWasmInitialized) {
30208 throw new Error("initializeWasm() must be awaited first!");
30210 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
30211 return nativeResponseValue;
30213 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
30215 export function RouteHintHop_write(obj: number): number {
30216 if(!isWasmInitialized) {
30217 throw new Error("initializeWasm() must be awaited first!");
30219 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
30220 return nativeResponseValue;
30222 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
30224 export function RouteHintHop_read(ser: number): number {
30225 if(!isWasmInitialized) {
30226 throw new Error("initializeWasm() must be awaited first!");
30228 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
30229 return nativeResponseValue;
30231 // 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]);
30233 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 {
30234 if(!isWasmInitialized) {
30235 throw new Error("initializeWasm() must be awaited first!");
30237 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
30238 return nativeResponseValue;
30240 // 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]);
30242 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 {
30243 if(!isWasmInitialized) {
30244 throw new Error("initializeWasm() must be awaited first!");
30246 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
30247 return nativeResponseValue;
30249 // void Score_free(struct LDKScore this_ptr);
30251 export function Score_free(this_ptr: number): void {
30252 if(!isWasmInitialized) {
30253 throw new Error("initializeWasm() must be awaited first!");
30255 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
30256 // debug statements here
30258 // void LockableScore_free(struct LDKLockableScore this_ptr);
30260 export function LockableScore_free(this_ptr: number): void {
30261 if(!isWasmInitialized) {
30262 throw new Error("initializeWasm() must be awaited first!");
30264 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
30265 // debug statements here
30267 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
30269 export function MultiThreadedLockableScore_free(this_obj: number): void {
30270 if(!isWasmInitialized) {
30271 throw new Error("initializeWasm() must be awaited first!");
30273 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
30274 // debug statements here
30276 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
30278 export function MultiThreadedLockableScore_write(obj: number): number {
30279 if(!isWasmInitialized) {
30280 throw new Error("initializeWasm() must be awaited first!");
30282 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
30283 return nativeResponseValue;
30285 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
30287 export function MultiThreadedLockableScore_new(score: number): number {
30288 if(!isWasmInitialized) {
30289 throw new Error("initializeWasm() must be awaited first!");
30291 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
30292 return nativeResponseValue;
30294 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
30296 export function ChannelUsage_free(this_obj: number): void {
30297 if(!isWasmInitialized) {
30298 throw new Error("initializeWasm() must be awaited first!");
30300 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
30301 // debug statements here
30303 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
30305 export function ChannelUsage_get_amount_msat(this_ptr: number): bigint {
30306 if(!isWasmInitialized) {
30307 throw new Error("initializeWasm() must be awaited first!");
30309 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
30310 return nativeResponseValue;
30312 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
30314 export function ChannelUsage_set_amount_msat(this_ptr: number, val: bigint): void {
30315 if(!isWasmInitialized) {
30316 throw new Error("initializeWasm() must be awaited first!");
30318 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
30319 // debug statements here
30321 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
30323 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: number): bigint {
30324 if(!isWasmInitialized) {
30325 throw new Error("initializeWasm() must be awaited first!");
30327 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
30328 return nativeResponseValue;
30330 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
30332 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: number, val: bigint): void {
30333 if(!isWasmInitialized) {
30334 throw new Error("initializeWasm() must be awaited first!");
30336 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
30337 // debug statements here
30339 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
30341 export function ChannelUsage_get_effective_capacity(this_ptr: number): number {
30342 if(!isWasmInitialized) {
30343 throw new Error("initializeWasm() must be awaited first!");
30345 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
30346 return nativeResponseValue;
30348 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
30350 export function ChannelUsage_set_effective_capacity(this_ptr: number, val: number): void {
30351 if(!isWasmInitialized) {
30352 throw new Error("initializeWasm() must be awaited first!");
30354 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
30355 // debug statements here
30357 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
30359 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: number): number {
30360 if(!isWasmInitialized) {
30361 throw new Error("initializeWasm() must be awaited first!");
30363 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
30364 return nativeResponseValue;
30366 // uintptr_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
30368 export function ChannelUsage_clone_ptr(arg: number): number {
30369 if(!isWasmInitialized) {
30370 throw new Error("initializeWasm() must be awaited first!");
30372 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
30373 return nativeResponseValue;
30375 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
30377 export function ChannelUsage_clone(orig: number): number {
30378 if(!isWasmInitialized) {
30379 throw new Error("initializeWasm() must be awaited first!");
30381 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
30382 return nativeResponseValue;
30384 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
30386 export function FixedPenaltyScorer_free(this_obj: number): void {
30387 if(!isWasmInitialized) {
30388 throw new Error("initializeWasm() must be awaited first!");
30390 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
30391 // debug statements here
30393 // uintptr_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
30395 export function FixedPenaltyScorer_clone_ptr(arg: number): number {
30396 if(!isWasmInitialized) {
30397 throw new Error("initializeWasm() must be awaited first!");
30399 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
30400 return nativeResponseValue;
30402 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
30404 export function FixedPenaltyScorer_clone(orig: number): number {
30405 if(!isWasmInitialized) {
30406 throw new Error("initializeWasm() must be awaited first!");
30408 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
30409 return nativeResponseValue;
30411 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
30413 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): number {
30414 if(!isWasmInitialized) {
30415 throw new Error("initializeWasm() must be awaited first!");
30417 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
30418 return nativeResponseValue;
30420 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
30422 export function FixedPenaltyScorer_as_Score(this_arg: number): number {
30423 if(!isWasmInitialized) {
30424 throw new Error("initializeWasm() must be awaited first!");
30426 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
30427 return nativeResponseValue;
30429 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
30431 export function FixedPenaltyScorer_write(obj: number): number {
30432 if(!isWasmInitialized) {
30433 throw new Error("initializeWasm() must be awaited first!");
30435 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
30436 return nativeResponseValue;
30438 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
30440 export function FixedPenaltyScorer_read(ser: number, arg: bigint): number {
30441 if(!isWasmInitialized) {
30442 throw new Error("initializeWasm() must be awaited first!");
30444 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
30445 return nativeResponseValue;
30447 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
30449 export function ProbabilisticScorer_free(this_obj: number): void {
30450 if(!isWasmInitialized) {
30451 throw new Error("initializeWasm() must be awaited first!");
30453 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
30454 // debug statements here
30456 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
30458 export function ProbabilisticScoringParameters_free(this_obj: number): void {
30459 if(!isWasmInitialized) {
30460 throw new Error("initializeWasm() must be awaited first!");
30462 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
30463 // debug statements here
30465 // uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30467 export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: number): bigint {
30468 if(!isWasmInitialized) {
30469 throw new Error("initializeWasm() must be awaited first!");
30471 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
30472 return nativeResponseValue;
30474 // void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30476 export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: number, val: bigint): void {
30477 if(!isWasmInitialized) {
30478 throw new Error("initializeWasm() must be awaited first!");
30480 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
30481 // debug statements here
30483 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30485 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: number): bigint {
30486 if(!isWasmInitialized) {
30487 throw new Error("initializeWasm() must be awaited first!");
30489 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
30490 return nativeResponseValue;
30492 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30494 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
30495 if(!isWasmInitialized) {
30496 throw new Error("initializeWasm() must be awaited first!");
30498 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
30499 // debug statements here
30501 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30503 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: number): bigint {
30504 if(!isWasmInitialized) {
30505 throw new Error("initializeWasm() must be awaited first!");
30507 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
30508 return nativeResponseValue;
30510 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30512 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: number, val: bigint): void {
30513 if(!isWasmInitialized) {
30514 throw new Error("initializeWasm() must be awaited first!");
30516 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
30517 // debug statements here
30519 // uint64_t ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30521 export function ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(this_ptr: number): bigint {
30522 if(!isWasmInitialized) {
30523 throw new Error("initializeWasm() must be awaited first!");
30525 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(this_ptr);
30526 return nativeResponseValue;
30528 // void ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30530 export function ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
30531 if(!isWasmInitialized) {
30532 throw new Error("initializeWasm() must be awaited first!");
30534 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(this_ptr, val);
30535 // debug statements here
30537 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_new(uint64_t base_penalty_msat_arg, uint64_t liquidity_penalty_multiplier_msat_arg, uint64_t liquidity_offset_half_life_arg, uint64_t amount_penalty_multiplier_msat_arg);
30539 export function ProbabilisticScoringParameters_new(base_penalty_msat_arg: bigint, liquidity_penalty_multiplier_msat_arg: bigint, liquidity_offset_half_life_arg: bigint, amount_penalty_multiplier_msat_arg: bigint): number {
30540 if(!isWasmInitialized) {
30541 throw new Error("initializeWasm() must be awaited first!");
30543 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_new(base_penalty_msat_arg, liquidity_penalty_multiplier_msat_arg, liquidity_offset_half_life_arg, amount_penalty_multiplier_msat_arg);
30544 return nativeResponseValue;
30546 // uintptr_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
30548 export function ProbabilisticScoringParameters_clone_ptr(arg: number): number {
30549 if(!isWasmInitialized) {
30550 throw new Error("initializeWasm() must be awaited first!");
30552 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
30553 return nativeResponseValue;
30555 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
30557 export function ProbabilisticScoringParameters_clone(orig: number): number {
30558 if(!isWasmInitialized) {
30559 throw new Error("initializeWasm() must be awaited first!");
30561 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
30562 return nativeResponseValue;
30564 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
30566 export function ProbabilisticScorer_new(params: number, network_graph: number, logger: number): number {
30567 if(!isWasmInitialized) {
30568 throw new Error("initializeWasm() must be awaited first!");
30570 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
30571 return nativeResponseValue;
30573 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
30575 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: number): void {
30576 if(!isWasmInitialized) {
30577 throw new Error("initializeWasm() must be awaited first!");
30579 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
30580 // debug statements here
30582 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
30584 export function ProbabilisticScoringParameters_default(): number {
30585 if(!isWasmInitialized) {
30586 throw new Error("initializeWasm() must be awaited first!");
30588 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
30589 return nativeResponseValue;
30591 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
30593 export function ProbabilisticScorer_as_Score(this_arg: number): number {
30594 if(!isWasmInitialized) {
30595 throw new Error("initializeWasm() must be awaited first!");
30597 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
30598 return nativeResponseValue;
30600 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
30602 export function ProbabilisticScorer_write(obj: number): number {
30603 if(!isWasmInitialized) {
30604 throw new Error("initializeWasm() must be awaited first!");
30606 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
30607 return nativeResponseValue;
30609 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
30611 export function ProbabilisticScorer_read(ser: number, arg_a: number, arg_b: number, arg_c: number): number {
30612 if(!isWasmInitialized) {
30613 throw new Error("initializeWasm() must be awaited first!");
30615 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
30616 return nativeResponseValue;
30618 // void ParseError_free(struct LDKParseError this_ptr);
30620 export function ParseError_free(this_ptr: number): void {
30621 if(!isWasmInitialized) {
30622 throw new Error("initializeWasm() must be awaited first!");
30624 const nativeResponseValue = wasm.TS_ParseError_free(this_ptr);
30625 // debug statements here
30627 // uintptr_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg);
30629 export function ParseError_clone_ptr(arg: number): number {
30630 if(!isWasmInitialized) {
30631 throw new Error("initializeWasm() must be awaited first!");
30633 const nativeResponseValue = wasm.TS_ParseError_clone_ptr(arg);
30634 return nativeResponseValue;
30636 // struct LDKParseError ParseError_clone(const struct LDKParseError *NONNULL_PTR orig);
30638 export function ParseError_clone(orig: number): number {
30639 if(!isWasmInitialized) {
30640 throw new Error("initializeWasm() must be awaited first!");
30642 const nativeResponseValue = wasm.TS_ParseError_clone(orig);
30643 return nativeResponseValue;
30645 // struct LDKParseError ParseError_bech32_error(struct LDKBech32Error a);
30647 export function ParseError_bech32_error(a: number): number {
30648 if(!isWasmInitialized) {
30649 throw new Error("initializeWasm() must be awaited first!");
30651 const nativeResponseValue = wasm.TS_ParseError_bech32_error(a);
30652 return nativeResponseValue;
30654 // struct LDKParseError ParseError_parse_amount_error(struct LDKError a);
30656 export function ParseError_parse_amount_error(a: number): number {
30657 if(!isWasmInitialized) {
30658 throw new Error("initializeWasm() must be awaited first!");
30660 const nativeResponseValue = wasm.TS_ParseError_parse_amount_error(a);
30661 return nativeResponseValue;
30663 // struct LDKParseError ParseError_malformed_signature(enum LDKSecp256k1Error a);
30665 export function ParseError_malformed_signature(a: Secp256k1Error): number {
30666 if(!isWasmInitialized) {
30667 throw new Error("initializeWasm() must be awaited first!");
30669 const nativeResponseValue = wasm.TS_ParseError_malformed_signature(a);
30670 return nativeResponseValue;
30672 // struct LDKParseError ParseError_bad_prefix(void);
30674 export function ParseError_bad_prefix(): number {
30675 if(!isWasmInitialized) {
30676 throw new Error("initializeWasm() must be awaited first!");
30678 const nativeResponseValue = wasm.TS_ParseError_bad_prefix();
30679 return nativeResponseValue;
30681 // struct LDKParseError ParseError_unknown_currency(void);
30683 export function ParseError_unknown_currency(): number {
30684 if(!isWasmInitialized) {
30685 throw new Error("initializeWasm() must be awaited first!");
30687 const nativeResponseValue = wasm.TS_ParseError_unknown_currency();
30688 return nativeResponseValue;
30690 // struct LDKParseError ParseError_unknown_si_prefix(void);
30692 export function ParseError_unknown_si_prefix(): number {
30693 if(!isWasmInitialized) {
30694 throw new Error("initializeWasm() must be awaited first!");
30696 const nativeResponseValue = wasm.TS_ParseError_unknown_si_prefix();
30697 return nativeResponseValue;
30699 // struct LDKParseError ParseError_malformed_hrp(void);
30701 export function ParseError_malformed_hrp(): number {
30702 if(!isWasmInitialized) {
30703 throw new Error("initializeWasm() must be awaited first!");
30705 const nativeResponseValue = wasm.TS_ParseError_malformed_hrp();
30706 return nativeResponseValue;
30708 // struct LDKParseError ParseError_too_short_data_part(void);
30710 export function ParseError_too_short_data_part(): number {
30711 if(!isWasmInitialized) {
30712 throw new Error("initializeWasm() must be awaited first!");
30714 const nativeResponseValue = wasm.TS_ParseError_too_short_data_part();
30715 return nativeResponseValue;
30717 // struct LDKParseError ParseError_unexpected_end_of_tagged_fields(void);
30719 export function ParseError_unexpected_end_of_tagged_fields(): number {
30720 if(!isWasmInitialized) {
30721 throw new Error("initializeWasm() must be awaited first!");
30723 const nativeResponseValue = wasm.TS_ParseError_unexpected_end_of_tagged_fields();
30724 return nativeResponseValue;
30726 // struct LDKParseError ParseError_description_decode_error(struct LDKError a);
30728 export function ParseError_description_decode_error(a: number): number {
30729 if(!isWasmInitialized) {
30730 throw new Error("initializeWasm() must be awaited first!");
30732 const nativeResponseValue = wasm.TS_ParseError_description_decode_error(a);
30733 return nativeResponseValue;
30735 // struct LDKParseError ParseError_padding_error(void);
30737 export function ParseError_padding_error(): number {
30738 if(!isWasmInitialized) {
30739 throw new Error("initializeWasm() must be awaited first!");
30741 const nativeResponseValue = wasm.TS_ParseError_padding_error();
30742 return nativeResponseValue;
30744 // struct LDKParseError ParseError_integer_overflow_error(void);
30746 export function ParseError_integer_overflow_error(): number {
30747 if(!isWasmInitialized) {
30748 throw new Error("initializeWasm() must be awaited first!");
30750 const nativeResponseValue = wasm.TS_ParseError_integer_overflow_error();
30751 return nativeResponseValue;
30753 // struct LDKParseError ParseError_invalid_seg_wit_program_length(void);
30755 export function ParseError_invalid_seg_wit_program_length(): number {
30756 if(!isWasmInitialized) {
30757 throw new Error("initializeWasm() must be awaited first!");
30759 const nativeResponseValue = wasm.TS_ParseError_invalid_seg_wit_program_length();
30760 return nativeResponseValue;
30762 // struct LDKParseError ParseError_invalid_pub_key_hash_length(void);
30764 export function ParseError_invalid_pub_key_hash_length(): number {
30765 if(!isWasmInitialized) {
30766 throw new Error("initializeWasm() must be awaited first!");
30768 const nativeResponseValue = wasm.TS_ParseError_invalid_pub_key_hash_length();
30769 return nativeResponseValue;
30771 // struct LDKParseError ParseError_invalid_script_hash_length(void);
30773 export function ParseError_invalid_script_hash_length(): number {
30774 if(!isWasmInitialized) {
30775 throw new Error("initializeWasm() must be awaited first!");
30777 const nativeResponseValue = wasm.TS_ParseError_invalid_script_hash_length();
30778 return nativeResponseValue;
30780 // struct LDKParseError ParseError_invalid_recovery_id(void);
30782 export function ParseError_invalid_recovery_id(): number {
30783 if(!isWasmInitialized) {
30784 throw new Error("initializeWasm() must be awaited first!");
30786 const nativeResponseValue = wasm.TS_ParseError_invalid_recovery_id();
30787 return nativeResponseValue;
30789 // struct LDKParseError ParseError_invalid_slice_length(struct LDKStr a);
30791 export function ParseError_invalid_slice_length(a: number): number {
30792 if(!isWasmInitialized) {
30793 throw new Error("initializeWasm() must be awaited first!");
30795 const nativeResponseValue = wasm.TS_ParseError_invalid_slice_length(a);
30796 return nativeResponseValue;
30798 // struct LDKParseError ParseError_skip(void);
30800 export function ParseError_skip(): number {
30801 if(!isWasmInitialized) {
30802 throw new Error("initializeWasm() must be awaited first!");
30804 const nativeResponseValue = wasm.TS_ParseError_skip();
30805 return nativeResponseValue;
30807 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
30809 export function ParseOrSemanticError_free(this_ptr: number): void {
30810 if(!isWasmInitialized) {
30811 throw new Error("initializeWasm() must be awaited first!");
30813 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
30814 // debug statements here
30816 // uintptr_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
30818 export function ParseOrSemanticError_clone_ptr(arg: number): number {
30819 if(!isWasmInitialized) {
30820 throw new Error("initializeWasm() must be awaited first!");
30822 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
30823 return nativeResponseValue;
30825 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
30827 export function ParseOrSemanticError_clone(orig: number): number {
30828 if(!isWasmInitialized) {
30829 throw new Error("initializeWasm() must be awaited first!");
30831 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
30832 return nativeResponseValue;
30834 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKParseError a);
30836 export function ParseOrSemanticError_parse_error(a: number): number {
30837 if(!isWasmInitialized) {
30838 throw new Error("initializeWasm() must be awaited first!");
30840 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
30841 return nativeResponseValue;
30843 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKSemanticError a);
30845 export function ParseOrSemanticError_semantic_error(a: SemanticError): number {
30846 if(!isWasmInitialized) {
30847 throw new Error("initializeWasm() must be awaited first!");
30849 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
30850 return nativeResponseValue;
30852 // void Invoice_free(struct LDKInvoice this_obj);
30854 export function Invoice_free(this_obj: number): void {
30855 if(!isWasmInitialized) {
30856 throw new Error("initializeWasm() must be awaited first!");
30858 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
30859 // debug statements here
30861 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
30863 export function Invoice_eq(a: number, b: number): boolean {
30864 if(!isWasmInitialized) {
30865 throw new Error("initializeWasm() must be awaited first!");
30867 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
30868 return nativeResponseValue;
30870 // uintptr_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
30872 export function Invoice_clone_ptr(arg: number): number {
30873 if(!isWasmInitialized) {
30874 throw new Error("initializeWasm() must be awaited first!");
30876 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
30877 return nativeResponseValue;
30879 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
30881 export function Invoice_clone(orig: number): number {
30882 if(!isWasmInitialized) {
30883 throw new Error("initializeWasm() must be awaited first!");
30885 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
30886 return nativeResponseValue;
30888 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
30890 export function SignedRawInvoice_free(this_obj: number): void {
30891 if(!isWasmInitialized) {
30892 throw new Error("initializeWasm() must be awaited first!");
30894 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
30895 // debug statements here
30897 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
30899 export function SignedRawInvoice_eq(a: number, b: number): boolean {
30900 if(!isWasmInitialized) {
30901 throw new Error("initializeWasm() must be awaited first!");
30903 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
30904 return nativeResponseValue;
30906 // uintptr_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
30908 export function SignedRawInvoice_clone_ptr(arg: number): number {
30909 if(!isWasmInitialized) {
30910 throw new Error("initializeWasm() must be awaited first!");
30912 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
30913 return nativeResponseValue;
30915 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
30917 export function SignedRawInvoice_clone(orig: number): number {
30918 if(!isWasmInitialized) {
30919 throw new Error("initializeWasm() must be awaited first!");
30921 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
30922 return nativeResponseValue;
30924 // void RawInvoice_free(struct LDKRawInvoice this_obj);
30926 export function RawInvoice_free(this_obj: number): void {
30927 if(!isWasmInitialized) {
30928 throw new Error("initializeWasm() must be awaited first!");
30930 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
30931 // debug statements here
30933 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
30935 export function RawInvoice_get_data(this_ptr: number): number {
30936 if(!isWasmInitialized) {
30937 throw new Error("initializeWasm() must be awaited first!");
30939 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
30940 return nativeResponseValue;
30942 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
30944 export function RawInvoice_set_data(this_ptr: number, val: number): void {
30945 if(!isWasmInitialized) {
30946 throw new Error("initializeWasm() must be awaited first!");
30948 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
30949 // debug statements here
30951 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
30953 export function RawInvoice_eq(a: number, b: number): boolean {
30954 if(!isWasmInitialized) {
30955 throw new Error("initializeWasm() must be awaited first!");
30957 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
30958 return nativeResponseValue;
30960 // uintptr_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
30962 export function RawInvoice_clone_ptr(arg: number): number {
30963 if(!isWasmInitialized) {
30964 throw new Error("initializeWasm() must be awaited first!");
30966 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
30967 return nativeResponseValue;
30969 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
30971 export function RawInvoice_clone(orig: number): number {
30972 if(!isWasmInitialized) {
30973 throw new Error("initializeWasm() must be awaited first!");
30975 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
30976 return nativeResponseValue;
30978 // void RawDataPart_free(struct LDKRawDataPart this_obj);
30980 export function RawDataPart_free(this_obj: number): void {
30981 if(!isWasmInitialized) {
30982 throw new Error("initializeWasm() must be awaited first!");
30984 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
30985 // debug statements here
30987 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
30989 export function RawDataPart_get_timestamp(this_ptr: number): number {
30990 if(!isWasmInitialized) {
30991 throw new Error("initializeWasm() must be awaited first!");
30993 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
30994 return nativeResponseValue;
30996 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
30998 export function RawDataPart_set_timestamp(this_ptr: number, val: number): void {
30999 if(!isWasmInitialized) {
31000 throw new Error("initializeWasm() must be awaited first!");
31002 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
31003 // debug statements here
31005 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
31007 export function RawDataPart_eq(a: number, b: number): boolean {
31008 if(!isWasmInitialized) {
31009 throw new Error("initializeWasm() must be awaited first!");
31011 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
31012 return nativeResponseValue;
31014 // uintptr_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
31016 export function RawDataPart_clone_ptr(arg: number): number {
31017 if(!isWasmInitialized) {
31018 throw new Error("initializeWasm() must be awaited first!");
31020 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
31021 return nativeResponseValue;
31023 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
31025 export function RawDataPart_clone(orig: number): number {
31026 if(!isWasmInitialized) {
31027 throw new Error("initializeWasm() must be awaited first!");
31029 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
31030 return nativeResponseValue;
31032 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
31034 export function PositiveTimestamp_free(this_obj: number): void {
31035 if(!isWasmInitialized) {
31036 throw new Error("initializeWasm() must be awaited first!");
31038 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
31039 // debug statements here
31041 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
31043 export function PositiveTimestamp_eq(a: number, b: number): boolean {
31044 if(!isWasmInitialized) {
31045 throw new Error("initializeWasm() must be awaited first!");
31047 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
31048 return nativeResponseValue;
31050 // uintptr_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
31052 export function PositiveTimestamp_clone_ptr(arg: number): number {
31053 if(!isWasmInitialized) {
31054 throw new Error("initializeWasm() must be awaited first!");
31056 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
31057 return nativeResponseValue;
31059 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
31061 export function PositiveTimestamp_clone(orig: number): number {
31062 if(!isWasmInitialized) {
31063 throw new Error("initializeWasm() must be awaited first!");
31065 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
31066 return nativeResponseValue;
31068 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
31070 export function SiPrefix_clone(orig: number): SiPrefix {
31071 if(!isWasmInitialized) {
31072 throw new Error("initializeWasm() must be awaited first!");
31074 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
31075 return nativeResponseValue;
31077 // enum LDKSiPrefix SiPrefix_milli(void);
31079 export function SiPrefix_milli(): SiPrefix {
31080 if(!isWasmInitialized) {
31081 throw new Error("initializeWasm() must be awaited first!");
31083 const nativeResponseValue = wasm.TS_SiPrefix_milli();
31084 return nativeResponseValue;
31086 // enum LDKSiPrefix SiPrefix_micro(void);
31088 export function SiPrefix_micro(): SiPrefix {
31089 if(!isWasmInitialized) {
31090 throw new Error("initializeWasm() must be awaited first!");
31092 const nativeResponseValue = wasm.TS_SiPrefix_micro();
31093 return nativeResponseValue;
31095 // enum LDKSiPrefix SiPrefix_nano(void);
31097 export function SiPrefix_nano(): SiPrefix {
31098 if(!isWasmInitialized) {
31099 throw new Error("initializeWasm() must be awaited first!");
31101 const nativeResponseValue = wasm.TS_SiPrefix_nano();
31102 return nativeResponseValue;
31104 // enum LDKSiPrefix SiPrefix_pico(void);
31106 export function SiPrefix_pico(): SiPrefix {
31107 if(!isWasmInitialized) {
31108 throw new Error("initializeWasm() must be awaited first!");
31110 const nativeResponseValue = wasm.TS_SiPrefix_pico();
31111 return nativeResponseValue;
31113 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
31115 export function SiPrefix_eq(a: number, b: number): boolean {
31116 if(!isWasmInitialized) {
31117 throw new Error("initializeWasm() must be awaited first!");
31119 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
31120 return nativeResponseValue;
31122 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
31124 export function SiPrefix_multiplier(this_arg: number): bigint {
31125 if(!isWasmInitialized) {
31126 throw new Error("initializeWasm() must be awaited first!");
31128 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
31129 return nativeResponseValue;
31131 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
31133 export function Currency_clone(orig: number): Currency {
31134 if(!isWasmInitialized) {
31135 throw new Error("initializeWasm() must be awaited first!");
31137 const nativeResponseValue = wasm.TS_Currency_clone(orig);
31138 return nativeResponseValue;
31140 // enum LDKCurrency Currency_bitcoin(void);
31142 export function Currency_bitcoin(): Currency {
31143 if(!isWasmInitialized) {
31144 throw new Error("initializeWasm() must be awaited first!");
31146 const nativeResponseValue = wasm.TS_Currency_bitcoin();
31147 return nativeResponseValue;
31149 // enum LDKCurrency Currency_bitcoin_testnet(void);
31151 export function Currency_bitcoin_testnet(): Currency {
31152 if(!isWasmInitialized) {
31153 throw new Error("initializeWasm() must be awaited first!");
31155 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
31156 return nativeResponseValue;
31158 // enum LDKCurrency Currency_regtest(void);
31160 export function Currency_regtest(): Currency {
31161 if(!isWasmInitialized) {
31162 throw new Error("initializeWasm() must be awaited first!");
31164 const nativeResponseValue = wasm.TS_Currency_regtest();
31165 return nativeResponseValue;
31167 // enum LDKCurrency Currency_simnet(void);
31169 export function Currency_simnet(): Currency {
31170 if(!isWasmInitialized) {
31171 throw new Error("initializeWasm() must be awaited first!");
31173 const nativeResponseValue = wasm.TS_Currency_simnet();
31174 return nativeResponseValue;
31176 // enum LDKCurrency Currency_signet(void);
31178 export function Currency_signet(): Currency {
31179 if(!isWasmInitialized) {
31180 throw new Error("initializeWasm() must be awaited first!");
31182 const nativeResponseValue = wasm.TS_Currency_signet();
31183 return nativeResponseValue;
31185 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
31187 export function Currency_hash(o: number): bigint {
31188 if(!isWasmInitialized) {
31189 throw new Error("initializeWasm() must be awaited first!");
31191 const nativeResponseValue = wasm.TS_Currency_hash(o);
31192 return nativeResponseValue;
31194 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
31196 export function Currency_eq(a: number, b: number): boolean {
31197 if(!isWasmInitialized) {
31198 throw new Error("initializeWasm() must be awaited first!");
31200 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
31201 return nativeResponseValue;
31203 // void Sha256_free(struct LDKSha256 this_obj);
31205 export function Sha256_free(this_obj: number): void {
31206 if(!isWasmInitialized) {
31207 throw new Error("initializeWasm() must be awaited first!");
31209 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
31210 // debug statements here
31212 // uintptr_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
31214 export function Sha256_clone_ptr(arg: number): number {
31215 if(!isWasmInitialized) {
31216 throw new Error("initializeWasm() must be awaited first!");
31218 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
31219 return nativeResponseValue;
31221 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
31223 export function Sha256_clone(orig: number): number {
31224 if(!isWasmInitialized) {
31225 throw new Error("initializeWasm() must be awaited first!");
31227 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
31228 return nativeResponseValue;
31230 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
31232 export function Sha256_hash(o: number): bigint {
31233 if(!isWasmInitialized) {
31234 throw new Error("initializeWasm() must be awaited first!");
31236 const nativeResponseValue = wasm.TS_Sha256_hash(o);
31237 return nativeResponseValue;
31239 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
31241 export function Sha256_eq(a: number, b: number): boolean {
31242 if(!isWasmInitialized) {
31243 throw new Error("initializeWasm() must be awaited first!");
31245 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
31246 return nativeResponseValue;
31248 // void Description_free(struct LDKDescription this_obj);
31250 export function Description_free(this_obj: number): void {
31251 if(!isWasmInitialized) {
31252 throw new Error("initializeWasm() must be awaited first!");
31254 const nativeResponseValue = wasm.TS_Description_free(this_obj);
31255 // debug statements here
31257 // uintptr_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
31259 export function Description_clone_ptr(arg: number): number {
31260 if(!isWasmInitialized) {
31261 throw new Error("initializeWasm() must be awaited first!");
31263 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
31264 return nativeResponseValue;
31266 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
31268 export function Description_clone(orig: number): number {
31269 if(!isWasmInitialized) {
31270 throw new Error("initializeWasm() must be awaited first!");
31272 const nativeResponseValue = wasm.TS_Description_clone(orig);
31273 return nativeResponseValue;
31275 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
31277 export function Description_hash(o: number): bigint {
31278 if(!isWasmInitialized) {
31279 throw new Error("initializeWasm() must be awaited first!");
31281 const nativeResponseValue = wasm.TS_Description_hash(o);
31282 return nativeResponseValue;
31284 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
31286 export function Description_eq(a: number, b: number): boolean {
31287 if(!isWasmInitialized) {
31288 throw new Error("initializeWasm() must be awaited first!");
31290 const nativeResponseValue = wasm.TS_Description_eq(a, b);
31291 return nativeResponseValue;
31293 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
31295 export function PayeePubKey_free(this_obj: number): void {
31296 if(!isWasmInitialized) {
31297 throw new Error("initializeWasm() must be awaited first!");
31299 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
31300 // debug statements here
31302 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
31304 export function PayeePubKey_get_a(this_ptr: number): number {
31305 if(!isWasmInitialized) {
31306 throw new Error("initializeWasm() must be awaited first!");
31308 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
31309 return nativeResponseValue;
31311 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31313 export function PayeePubKey_set_a(this_ptr: number, val: number): void {
31314 if(!isWasmInitialized) {
31315 throw new Error("initializeWasm() must be awaited first!");
31317 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
31318 // debug statements here
31320 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
31322 export function PayeePubKey_new(a_arg: number): number {
31323 if(!isWasmInitialized) {
31324 throw new Error("initializeWasm() must be awaited first!");
31326 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
31327 return nativeResponseValue;
31329 // uintptr_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
31331 export function PayeePubKey_clone_ptr(arg: number): number {
31332 if(!isWasmInitialized) {
31333 throw new Error("initializeWasm() must be awaited first!");
31335 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
31336 return nativeResponseValue;
31338 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
31340 export function PayeePubKey_clone(orig: number): number {
31341 if(!isWasmInitialized) {
31342 throw new Error("initializeWasm() must be awaited first!");
31344 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
31345 return nativeResponseValue;
31347 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
31349 export function PayeePubKey_hash(o: number): bigint {
31350 if(!isWasmInitialized) {
31351 throw new Error("initializeWasm() must be awaited first!");
31353 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
31354 return nativeResponseValue;
31356 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
31358 export function PayeePubKey_eq(a: number, b: number): boolean {
31359 if(!isWasmInitialized) {
31360 throw new Error("initializeWasm() must be awaited first!");
31362 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
31363 return nativeResponseValue;
31365 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
31367 export function ExpiryTime_free(this_obj: number): void {
31368 if(!isWasmInitialized) {
31369 throw new Error("initializeWasm() must be awaited first!");
31371 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
31372 // debug statements here
31374 // uintptr_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
31376 export function ExpiryTime_clone_ptr(arg: number): number {
31377 if(!isWasmInitialized) {
31378 throw new Error("initializeWasm() must be awaited first!");
31380 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
31381 return nativeResponseValue;
31383 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
31385 export function ExpiryTime_clone(orig: number): number {
31386 if(!isWasmInitialized) {
31387 throw new Error("initializeWasm() must be awaited first!");
31389 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
31390 return nativeResponseValue;
31392 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
31394 export function ExpiryTime_hash(o: number): bigint {
31395 if(!isWasmInitialized) {
31396 throw new Error("initializeWasm() must be awaited first!");
31398 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
31399 return nativeResponseValue;
31401 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
31403 export function ExpiryTime_eq(a: number, b: number): boolean {
31404 if(!isWasmInitialized) {
31405 throw new Error("initializeWasm() must be awaited first!");
31407 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
31408 return nativeResponseValue;
31410 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
31412 export function MinFinalCltvExpiry_free(this_obj: number): void {
31413 if(!isWasmInitialized) {
31414 throw new Error("initializeWasm() must be awaited first!");
31416 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
31417 // debug statements here
31419 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
31421 export function MinFinalCltvExpiry_get_a(this_ptr: number): bigint {
31422 if(!isWasmInitialized) {
31423 throw new Error("initializeWasm() must be awaited first!");
31425 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
31426 return nativeResponseValue;
31428 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
31430 export function MinFinalCltvExpiry_set_a(this_ptr: number, val: bigint): void {
31431 if(!isWasmInitialized) {
31432 throw new Error("initializeWasm() must be awaited first!");
31434 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
31435 // debug statements here
31437 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
31439 export function MinFinalCltvExpiry_new(a_arg: bigint): number {
31440 if(!isWasmInitialized) {
31441 throw new Error("initializeWasm() must be awaited first!");
31443 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
31444 return nativeResponseValue;
31446 // uintptr_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
31448 export function MinFinalCltvExpiry_clone_ptr(arg: number): number {
31449 if(!isWasmInitialized) {
31450 throw new Error("initializeWasm() must be awaited first!");
31452 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
31453 return nativeResponseValue;
31455 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
31457 export function MinFinalCltvExpiry_clone(orig: number): number {
31458 if(!isWasmInitialized) {
31459 throw new Error("initializeWasm() must be awaited first!");
31461 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
31462 return nativeResponseValue;
31464 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
31466 export function MinFinalCltvExpiry_hash(o: number): bigint {
31467 if(!isWasmInitialized) {
31468 throw new Error("initializeWasm() must be awaited first!");
31470 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
31471 return nativeResponseValue;
31473 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
31475 export function MinFinalCltvExpiry_eq(a: number, b: number): boolean {
31476 if(!isWasmInitialized) {
31477 throw new Error("initializeWasm() must be awaited first!");
31479 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
31480 return nativeResponseValue;
31482 // void Fallback_free(struct LDKFallback this_ptr);
31484 export function Fallback_free(this_ptr: number): void {
31485 if(!isWasmInitialized) {
31486 throw new Error("initializeWasm() must be awaited first!");
31488 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
31489 // debug statements here
31491 // uintptr_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
31493 export function Fallback_clone_ptr(arg: number): number {
31494 if(!isWasmInitialized) {
31495 throw new Error("initializeWasm() must be awaited first!");
31497 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
31498 return nativeResponseValue;
31500 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
31502 export function Fallback_clone(orig: number): number {
31503 if(!isWasmInitialized) {
31504 throw new Error("initializeWasm() must be awaited first!");
31506 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
31507 return nativeResponseValue;
31509 // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
31511 export function Fallback_seg_wit_program(version: number, program: number): number {
31512 if(!isWasmInitialized) {
31513 throw new Error("initializeWasm() must be awaited first!");
31515 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
31516 return nativeResponseValue;
31518 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
31520 export function Fallback_pub_key_hash(a: number): number {
31521 if(!isWasmInitialized) {
31522 throw new Error("initializeWasm() must be awaited first!");
31524 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
31525 return nativeResponseValue;
31527 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
31529 export function Fallback_script_hash(a: number): number {
31530 if(!isWasmInitialized) {
31531 throw new Error("initializeWasm() must be awaited first!");
31533 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
31534 return nativeResponseValue;
31536 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
31538 export function Fallback_hash(o: number): bigint {
31539 if(!isWasmInitialized) {
31540 throw new Error("initializeWasm() must be awaited first!");
31542 const nativeResponseValue = wasm.TS_Fallback_hash(o);
31543 return nativeResponseValue;
31545 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
31547 export function Fallback_eq(a: number, b: number): boolean {
31548 if(!isWasmInitialized) {
31549 throw new Error("initializeWasm() must be awaited first!");
31551 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
31552 return nativeResponseValue;
31554 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
31556 export function InvoiceSignature_free(this_obj: number): void {
31557 if(!isWasmInitialized) {
31558 throw new Error("initializeWasm() must be awaited first!");
31560 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
31561 // debug statements here
31563 // uintptr_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
31565 export function InvoiceSignature_clone_ptr(arg: number): number {
31566 if(!isWasmInitialized) {
31567 throw new Error("initializeWasm() must be awaited first!");
31569 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
31570 return nativeResponseValue;
31572 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
31574 export function InvoiceSignature_clone(orig: number): number {
31575 if(!isWasmInitialized) {
31576 throw new Error("initializeWasm() must be awaited first!");
31578 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
31579 return nativeResponseValue;
31581 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
31583 export function InvoiceSignature_eq(a: number, b: number): boolean {
31584 if(!isWasmInitialized) {
31585 throw new Error("initializeWasm() must be awaited first!");
31587 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
31588 return nativeResponseValue;
31590 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
31592 export function PrivateRoute_free(this_obj: number): void {
31593 if(!isWasmInitialized) {
31594 throw new Error("initializeWasm() must be awaited first!");
31596 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
31597 // debug statements here
31599 // uintptr_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
31601 export function PrivateRoute_clone_ptr(arg: number): number {
31602 if(!isWasmInitialized) {
31603 throw new Error("initializeWasm() must be awaited first!");
31605 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
31606 return nativeResponseValue;
31608 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
31610 export function PrivateRoute_clone(orig: number): number {
31611 if(!isWasmInitialized) {
31612 throw new Error("initializeWasm() must be awaited first!");
31614 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
31615 return nativeResponseValue;
31617 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
31619 export function PrivateRoute_hash(o: number): bigint {
31620 if(!isWasmInitialized) {
31621 throw new Error("initializeWasm() must be awaited first!");
31623 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
31624 return nativeResponseValue;
31626 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
31628 export function PrivateRoute_eq(a: number, b: number): boolean {
31629 if(!isWasmInitialized) {
31630 throw new Error("initializeWasm() must be awaited first!");
31632 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
31633 return nativeResponseValue;
31635 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
31637 export function SignedRawInvoice_into_parts(this_arg: number): number {
31638 if(!isWasmInitialized) {
31639 throw new Error("initializeWasm() must be awaited first!");
31641 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
31642 return nativeResponseValue;
31644 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
31646 export function SignedRawInvoice_raw_invoice(this_arg: number): number {
31647 if(!isWasmInitialized) {
31648 throw new Error("initializeWasm() must be awaited first!");
31650 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
31651 return nativeResponseValue;
31653 // MUST_USE_RES const uint8_t (*SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
31655 export function SignedRawInvoice_hash(this_arg: number): number {
31656 if(!isWasmInitialized) {
31657 throw new Error("initializeWasm() must be awaited first!");
31659 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(this_arg);
31660 return nativeResponseValue;
31662 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
31664 export function SignedRawInvoice_signature(this_arg: number): number {
31665 if(!isWasmInitialized) {
31666 throw new Error("initializeWasm() must be awaited first!");
31668 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
31669 return nativeResponseValue;
31671 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
31673 export function SignedRawInvoice_recover_payee_pub_key(this_arg: number): number {
31674 if(!isWasmInitialized) {
31675 throw new Error("initializeWasm() must be awaited first!");
31677 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
31678 return nativeResponseValue;
31680 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
31682 export function SignedRawInvoice_check_signature(this_arg: number): boolean {
31683 if(!isWasmInitialized) {
31684 throw new Error("initializeWasm() must be awaited first!");
31686 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
31687 return nativeResponseValue;
31689 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31691 export function RawInvoice_hash(this_arg: number): number {
31692 if(!isWasmInitialized) {
31693 throw new Error("initializeWasm() must be awaited first!");
31695 const nativeResponseValue = wasm.TS_RawInvoice_hash(this_arg);
31696 return nativeResponseValue;
31698 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31700 export function RawInvoice_payment_hash(this_arg: number): number {
31701 if(!isWasmInitialized) {
31702 throw new Error("initializeWasm() must be awaited first!");
31704 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
31705 return nativeResponseValue;
31707 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31709 export function RawInvoice_description(this_arg: number): number {
31710 if(!isWasmInitialized) {
31711 throw new Error("initializeWasm() must be awaited first!");
31713 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
31714 return nativeResponseValue;
31716 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31718 export function RawInvoice_payee_pub_key(this_arg: number): number {
31719 if(!isWasmInitialized) {
31720 throw new Error("initializeWasm() must be awaited first!");
31722 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
31723 return nativeResponseValue;
31725 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31727 export function RawInvoice_description_hash(this_arg: number): number {
31728 if(!isWasmInitialized) {
31729 throw new Error("initializeWasm() must be awaited first!");
31731 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
31732 return nativeResponseValue;
31734 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31736 export function RawInvoice_expiry_time(this_arg: number): number {
31737 if(!isWasmInitialized) {
31738 throw new Error("initializeWasm() must be awaited first!");
31740 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
31741 return nativeResponseValue;
31743 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31745 export function RawInvoice_min_final_cltv_expiry(this_arg: number): number {
31746 if(!isWasmInitialized) {
31747 throw new Error("initializeWasm() must be awaited first!");
31749 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
31750 return nativeResponseValue;
31752 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31754 export function RawInvoice_payment_secret(this_arg: number): number {
31755 if(!isWasmInitialized) {
31756 throw new Error("initializeWasm() must be awaited first!");
31758 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
31759 return nativeResponseValue;
31761 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31763 export function RawInvoice_features(this_arg: number): number {
31764 if(!isWasmInitialized) {
31765 throw new Error("initializeWasm() must be awaited first!");
31767 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
31768 return nativeResponseValue;
31770 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31772 export function RawInvoice_private_routes(this_arg: number): number {
31773 if(!isWasmInitialized) {
31774 throw new Error("initializeWasm() must be awaited first!");
31776 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
31777 return nativeResponseValue;
31779 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31781 export function RawInvoice_amount_pico_btc(this_arg: number): number {
31782 if(!isWasmInitialized) {
31783 throw new Error("initializeWasm() must be awaited first!");
31785 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
31786 return nativeResponseValue;
31788 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
31790 export function RawInvoice_currency(this_arg: number): Currency {
31791 if(!isWasmInitialized) {
31792 throw new Error("initializeWasm() must be awaited first!");
31794 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
31795 return nativeResponseValue;
31797 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
31799 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): number {
31800 if(!isWasmInitialized) {
31801 throw new Error("initializeWasm() must be awaited first!");
31803 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
31804 return nativeResponseValue;
31806 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
31808 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): number {
31809 if(!isWasmInitialized) {
31810 throw new Error("initializeWasm() must be awaited first!");
31812 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
31813 return nativeResponseValue;
31815 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
31817 export function PositiveTimestamp_as_unix_timestamp(this_arg: number): bigint {
31818 if(!isWasmInitialized) {
31819 throw new Error("initializeWasm() must be awaited first!");
31821 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
31822 return nativeResponseValue;
31824 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
31826 export function PositiveTimestamp_as_duration_since_epoch(this_arg: number): bigint {
31827 if(!isWasmInitialized) {
31828 throw new Error("initializeWasm() must be awaited first!");
31830 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
31831 return nativeResponseValue;
31833 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
31835 export function Invoice_into_signed_raw(this_arg: number): number {
31836 if(!isWasmInitialized) {
31837 throw new Error("initializeWasm() must be awaited first!");
31839 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
31840 return nativeResponseValue;
31842 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
31844 export function Invoice_check_signature(this_arg: number): number {
31845 if(!isWasmInitialized) {
31846 throw new Error("initializeWasm() must be awaited first!");
31848 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
31849 return nativeResponseValue;
31851 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
31853 export function Invoice_from_signed(signed_invoice: number): number {
31854 if(!isWasmInitialized) {
31855 throw new Error("initializeWasm() must be awaited first!");
31857 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
31858 return nativeResponseValue;
31860 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
31862 export function Invoice_duration_since_epoch(this_arg: number): bigint {
31863 if(!isWasmInitialized) {
31864 throw new Error("initializeWasm() must be awaited first!");
31866 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
31867 return nativeResponseValue;
31869 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
31871 export function Invoice_payment_hash(this_arg: number): number {
31872 if(!isWasmInitialized) {
31873 throw new Error("initializeWasm() must be awaited first!");
31875 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
31876 return nativeResponseValue;
31878 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
31880 export function Invoice_payee_pub_key(this_arg: number): number {
31881 if(!isWasmInitialized) {
31882 throw new Error("initializeWasm() must be awaited first!");
31884 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
31885 return nativeResponseValue;
31887 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
31889 export function Invoice_payment_secret(this_arg: number): number {
31890 if(!isWasmInitialized) {
31891 throw new Error("initializeWasm() must be awaited first!");
31893 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
31894 return nativeResponseValue;
31896 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
31898 export function Invoice_features(this_arg: number): number {
31899 if(!isWasmInitialized) {
31900 throw new Error("initializeWasm() must be awaited first!");
31902 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
31903 return nativeResponseValue;
31905 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
31907 export function Invoice_recover_payee_pub_key(this_arg: number): number {
31908 if(!isWasmInitialized) {
31909 throw new Error("initializeWasm() must be awaited first!");
31911 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
31912 return nativeResponseValue;
31914 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
31916 export function Invoice_expiry_time(this_arg: number): bigint {
31917 if(!isWasmInitialized) {
31918 throw new Error("initializeWasm() must be awaited first!");
31920 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
31921 return nativeResponseValue;
31923 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
31925 export function Invoice_would_expire(this_arg: number, at_time: bigint): boolean {
31926 if(!isWasmInitialized) {
31927 throw new Error("initializeWasm() must be awaited first!");
31929 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
31930 return nativeResponseValue;
31932 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
31934 export function Invoice_min_final_cltv_expiry(this_arg: number): bigint {
31935 if(!isWasmInitialized) {
31936 throw new Error("initializeWasm() must be awaited first!");
31938 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
31939 return nativeResponseValue;
31941 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
31943 export function Invoice_private_routes(this_arg: number): number {
31944 if(!isWasmInitialized) {
31945 throw new Error("initializeWasm() must be awaited first!");
31947 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
31948 return nativeResponseValue;
31950 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
31952 export function Invoice_route_hints(this_arg: number): number {
31953 if(!isWasmInitialized) {
31954 throw new Error("initializeWasm() must be awaited first!");
31956 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
31957 return nativeResponseValue;
31959 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
31961 export function Invoice_currency(this_arg: number): Currency {
31962 if(!isWasmInitialized) {
31963 throw new Error("initializeWasm() must be awaited first!");
31965 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
31966 return nativeResponseValue;
31968 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
31970 export function Invoice_amount_milli_satoshis(this_arg: number): number {
31971 if(!isWasmInitialized) {
31972 throw new Error("initializeWasm() must be awaited first!");
31974 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
31975 return nativeResponseValue;
31977 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
31979 export function Description_new(description: number): number {
31980 if(!isWasmInitialized) {
31981 throw new Error("initializeWasm() must be awaited first!");
31983 const nativeResponseValue = wasm.TS_Description_new(description);
31984 return nativeResponseValue;
31986 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
31988 export function Description_into_inner(this_arg: number): number {
31989 if(!isWasmInitialized) {
31990 throw new Error("initializeWasm() must be awaited first!");
31992 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
31993 return nativeResponseValue;
31995 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
31997 export function ExpiryTime_from_seconds(seconds: bigint): number {
31998 if(!isWasmInitialized) {
31999 throw new Error("initializeWasm() must be awaited first!");
32001 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
32002 return nativeResponseValue;
32004 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
32006 export function ExpiryTime_from_duration(duration: bigint): number {
32007 if(!isWasmInitialized) {
32008 throw new Error("initializeWasm() must be awaited first!");
32010 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
32011 return nativeResponseValue;
32013 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
32015 export function ExpiryTime_as_seconds(this_arg: number): bigint {
32016 if(!isWasmInitialized) {
32017 throw new Error("initializeWasm() must be awaited first!");
32019 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
32020 return nativeResponseValue;
32022 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
32024 export function ExpiryTime_as_duration(this_arg: number): bigint {
32025 if(!isWasmInitialized) {
32026 throw new Error("initializeWasm() must be awaited first!");
32028 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
32029 return nativeResponseValue;
32031 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
32033 export function PrivateRoute_new(hops: number): number {
32034 if(!isWasmInitialized) {
32035 throw new Error("initializeWasm() must be awaited first!");
32037 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
32038 return nativeResponseValue;
32040 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
32042 export function PrivateRoute_into_inner(this_arg: number): number {
32043 if(!isWasmInitialized) {
32044 throw new Error("initializeWasm() must be awaited first!");
32046 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
32047 return nativeResponseValue;
32049 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
32051 export function CreationError_clone(orig: number): CreationError {
32052 if(!isWasmInitialized) {
32053 throw new Error("initializeWasm() must be awaited first!");
32055 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
32056 return nativeResponseValue;
32058 // enum LDKCreationError CreationError_description_too_long(void);
32060 export function CreationError_description_too_long(): CreationError {
32061 if(!isWasmInitialized) {
32062 throw new Error("initializeWasm() must be awaited first!");
32064 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
32065 return nativeResponseValue;
32067 // enum LDKCreationError CreationError_route_too_long(void);
32069 export function CreationError_route_too_long(): CreationError {
32070 if(!isWasmInitialized) {
32071 throw new Error("initializeWasm() must be awaited first!");
32073 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
32074 return nativeResponseValue;
32076 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
32078 export function CreationError_timestamp_out_of_bounds(): CreationError {
32079 if(!isWasmInitialized) {
32080 throw new Error("initializeWasm() must be awaited first!");
32082 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
32083 return nativeResponseValue;
32085 // enum LDKCreationError CreationError_invalid_amount(void);
32087 export function CreationError_invalid_amount(): CreationError {
32088 if(!isWasmInitialized) {
32089 throw new Error("initializeWasm() must be awaited first!");
32091 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
32092 return nativeResponseValue;
32094 // enum LDKCreationError CreationError_missing_route_hints(void);
32096 export function CreationError_missing_route_hints(): CreationError {
32097 if(!isWasmInitialized) {
32098 throw new Error("initializeWasm() must be awaited first!");
32100 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
32101 return nativeResponseValue;
32103 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
32105 export function CreationError_eq(a: number, b: number): boolean {
32106 if(!isWasmInitialized) {
32107 throw new Error("initializeWasm() must be awaited first!");
32109 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
32110 return nativeResponseValue;
32112 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
32114 export function CreationError_to_str(o: number): number {
32115 if(!isWasmInitialized) {
32116 throw new Error("initializeWasm() must be awaited first!");
32118 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
32119 return nativeResponseValue;
32121 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
32123 export function SemanticError_clone(orig: number): SemanticError {
32124 if(!isWasmInitialized) {
32125 throw new Error("initializeWasm() must be awaited first!");
32127 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
32128 return nativeResponseValue;
32130 // enum LDKSemanticError SemanticError_no_payment_hash(void);
32132 export function SemanticError_no_payment_hash(): SemanticError {
32133 if(!isWasmInitialized) {
32134 throw new Error("initializeWasm() must be awaited first!");
32136 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
32137 return nativeResponseValue;
32139 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
32141 export function SemanticError_multiple_payment_hashes(): SemanticError {
32142 if(!isWasmInitialized) {
32143 throw new Error("initializeWasm() must be awaited first!");
32145 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
32146 return nativeResponseValue;
32148 // enum LDKSemanticError SemanticError_no_description(void);
32150 export function SemanticError_no_description(): SemanticError {
32151 if(!isWasmInitialized) {
32152 throw new Error("initializeWasm() must be awaited first!");
32154 const nativeResponseValue = wasm.TS_SemanticError_no_description();
32155 return nativeResponseValue;
32157 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
32159 export function SemanticError_multiple_descriptions(): SemanticError {
32160 if(!isWasmInitialized) {
32161 throw new Error("initializeWasm() must be awaited first!");
32163 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
32164 return nativeResponseValue;
32166 // enum LDKSemanticError SemanticError_no_payment_secret(void);
32168 export function SemanticError_no_payment_secret(): SemanticError {
32169 if(!isWasmInitialized) {
32170 throw new Error("initializeWasm() must be awaited first!");
32172 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
32173 return nativeResponseValue;
32175 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
32177 export function SemanticError_multiple_payment_secrets(): SemanticError {
32178 if(!isWasmInitialized) {
32179 throw new Error("initializeWasm() must be awaited first!");
32181 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
32182 return nativeResponseValue;
32184 // enum LDKSemanticError SemanticError_invalid_features(void);
32186 export function SemanticError_invalid_features(): SemanticError {
32187 if(!isWasmInitialized) {
32188 throw new Error("initializeWasm() must be awaited first!");
32190 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
32191 return nativeResponseValue;
32193 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
32195 export function SemanticError_invalid_recovery_id(): SemanticError {
32196 if(!isWasmInitialized) {
32197 throw new Error("initializeWasm() must be awaited first!");
32199 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
32200 return nativeResponseValue;
32202 // enum LDKSemanticError SemanticError_invalid_signature(void);
32204 export function SemanticError_invalid_signature(): SemanticError {
32205 if(!isWasmInitialized) {
32206 throw new Error("initializeWasm() must be awaited first!");
32208 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
32209 return nativeResponseValue;
32211 // enum LDKSemanticError SemanticError_imprecise_amount(void);
32213 export function SemanticError_imprecise_amount(): SemanticError {
32214 if(!isWasmInitialized) {
32215 throw new Error("initializeWasm() must be awaited first!");
32217 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
32218 return nativeResponseValue;
32220 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
32222 export function SemanticError_eq(a: number, b: number): boolean {
32223 if(!isWasmInitialized) {
32224 throw new Error("initializeWasm() must be awaited first!");
32226 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
32227 return nativeResponseValue;
32229 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
32231 export function SemanticError_to_str(o: number): number {
32232 if(!isWasmInitialized) {
32233 throw new Error("initializeWasm() must be awaited first!");
32235 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
32236 return nativeResponseValue;
32238 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
32240 export function SignOrCreationError_free(this_ptr: number): void {
32241 if(!isWasmInitialized) {
32242 throw new Error("initializeWasm() must be awaited first!");
32244 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
32245 // debug statements here
32247 // uintptr_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
32249 export function SignOrCreationError_clone_ptr(arg: number): number {
32250 if(!isWasmInitialized) {
32251 throw new Error("initializeWasm() must be awaited first!");
32253 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
32254 return nativeResponseValue;
32256 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
32258 export function SignOrCreationError_clone(orig: number): number {
32259 if(!isWasmInitialized) {
32260 throw new Error("initializeWasm() must be awaited first!");
32262 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
32263 return nativeResponseValue;
32265 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
32267 export function SignOrCreationError_sign_error(): number {
32268 if(!isWasmInitialized) {
32269 throw new Error("initializeWasm() must be awaited first!");
32271 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
32272 return nativeResponseValue;
32274 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
32276 export function SignOrCreationError_creation_error(a: CreationError): number {
32277 if(!isWasmInitialized) {
32278 throw new Error("initializeWasm() must be awaited first!");
32280 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
32281 return nativeResponseValue;
32283 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
32285 export function SignOrCreationError_eq(a: number, b: number): boolean {
32286 if(!isWasmInitialized) {
32287 throw new Error("initializeWasm() must be awaited first!");
32289 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
32290 return nativeResponseValue;
32292 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
32294 export function SignOrCreationError_to_str(o: number): number {
32295 if(!isWasmInitialized) {
32296 throw new Error("initializeWasm() must be awaited first!");
32298 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
32299 return nativeResponseValue;
32301 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
32303 export function InvoicePayer_free(this_obj: number): void {
32304 if(!isWasmInitialized) {
32305 throw new Error("initializeWasm() must be awaited first!");
32307 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
32308 // debug statements here
32310 // void Payer_free(struct LDKPayer this_ptr);
32312 export function Payer_free(this_ptr: number): void {
32313 if(!isWasmInitialized) {
32314 throw new Error("initializeWasm() must be awaited first!");
32316 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
32317 // debug statements here
32319 // void Router_free(struct LDKRouter this_ptr);
32321 export function Router_free(this_ptr: number): void {
32322 if(!isWasmInitialized) {
32323 throw new Error("initializeWasm() must be awaited first!");
32325 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
32326 // debug statements here
32328 // void Retry_free(struct LDKRetry this_ptr);
32330 export function Retry_free(this_ptr: number): void {
32331 if(!isWasmInitialized) {
32332 throw new Error("initializeWasm() must be awaited first!");
32334 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
32335 // debug statements here
32337 // uintptr_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
32339 export function Retry_clone_ptr(arg: number): number {
32340 if(!isWasmInitialized) {
32341 throw new Error("initializeWasm() must be awaited first!");
32343 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
32344 return nativeResponseValue;
32346 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
32348 export function Retry_clone(orig: number): number {
32349 if(!isWasmInitialized) {
32350 throw new Error("initializeWasm() must be awaited first!");
32352 const nativeResponseValue = wasm.TS_Retry_clone(orig);
32353 return nativeResponseValue;
32355 // struct LDKRetry Retry_attempts(uintptr_t a);
32357 export function Retry_attempts(a: number): number {
32358 if(!isWasmInitialized) {
32359 throw new Error("initializeWasm() must be awaited first!");
32361 const nativeResponseValue = wasm.TS_Retry_attempts(a);
32362 return nativeResponseValue;
32364 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
32366 export function Retry_eq(a: number, b: number): boolean {
32367 if(!isWasmInitialized) {
32368 throw new Error("initializeWasm() must be awaited first!");
32370 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
32371 return nativeResponseValue;
32373 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
32375 export function Retry_hash(o: number): bigint {
32376 if(!isWasmInitialized) {
32377 throw new Error("initializeWasm() must be awaited first!");
32379 const nativeResponseValue = wasm.TS_Retry_hash(o);
32380 return nativeResponseValue;
32382 // void PaymentError_free(struct LDKPaymentError this_ptr);
32384 export function PaymentError_free(this_ptr: number): void {
32385 if(!isWasmInitialized) {
32386 throw new Error("initializeWasm() must be awaited first!");
32388 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
32389 // debug statements here
32391 // uintptr_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
32393 export function PaymentError_clone_ptr(arg: number): number {
32394 if(!isWasmInitialized) {
32395 throw new Error("initializeWasm() must be awaited first!");
32397 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
32398 return nativeResponseValue;
32400 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
32402 export function PaymentError_clone(orig: number): number {
32403 if(!isWasmInitialized) {
32404 throw new Error("initializeWasm() must be awaited first!");
32406 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
32407 return nativeResponseValue;
32409 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
32411 export function PaymentError_invoice(a: number): number {
32412 if(!isWasmInitialized) {
32413 throw new Error("initializeWasm() must be awaited first!");
32415 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
32416 return nativeResponseValue;
32418 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
32420 export function PaymentError_routing(a: number): number {
32421 if(!isWasmInitialized) {
32422 throw new Error("initializeWasm() must be awaited first!");
32424 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
32425 return nativeResponseValue;
32427 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
32429 export function PaymentError_sending(a: number): number {
32430 if(!isWasmInitialized) {
32431 throw new Error("initializeWasm() must be awaited first!");
32433 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
32434 return nativeResponseValue;
32436 // 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);
32438 export function InvoicePayer_new(payer: number, router: number, scorer: number, logger: number, event_handler: number, retry: number): number {
32439 if(!isWasmInitialized) {
32440 throw new Error("initializeWasm() must be awaited first!");
32442 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, scorer, logger, event_handler, retry);
32443 return nativeResponseValue;
32445 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
32447 export function InvoicePayer_pay_invoice(this_arg: number, invoice: number): number {
32448 if(!isWasmInitialized) {
32449 throw new Error("initializeWasm() must be awaited first!");
32451 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
32452 return nativeResponseValue;
32454 // 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);
32456 export function InvoicePayer_pay_zero_value_invoice(this_arg: number, invoice: number, amount_msats: bigint): number {
32457 if(!isWasmInitialized) {
32458 throw new Error("initializeWasm() must be awaited first!");
32460 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
32461 return nativeResponseValue;
32463 // 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);
32465 export function InvoicePayer_pay_pubkey(this_arg: number, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): number {
32466 if(!isWasmInitialized) {
32467 throw new Error("initializeWasm() must be awaited first!");
32469 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
32470 return nativeResponseValue;
32472 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
32474 export function InvoicePayer_remove_cached_payment(this_arg: number, payment_hash: number): void {
32475 if(!isWasmInitialized) {
32476 throw new Error("initializeWasm() must be awaited first!");
32478 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
32479 // debug statements here
32481 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
32483 export function InvoicePayer_as_EventHandler(this_arg: number): number {
32484 if(!isWasmInitialized) {
32485 throw new Error("initializeWasm() must be awaited first!");
32487 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
32488 return nativeResponseValue;
32490 // 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);
32492 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 {
32493 if(!isWasmInitialized) {
32494 throw new Error("initializeWasm() must be awaited first!");
32496 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);
32497 return nativeResponseValue;
32499 // 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);
32501 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 {
32502 if(!isWasmInitialized) {
32503 throw new Error("initializeWasm() must be awaited first!");
32505 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);
32506 return nativeResponseValue;
32508 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
32510 export function DefaultRouter_free(this_obj: number): void {
32511 if(!isWasmInitialized) {
32512 throw new Error("initializeWasm() must be awaited first!");
32514 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
32515 // debug statements here
32517 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes);
32519 export function DefaultRouter_new(network_graph: number, logger: number, random_seed_bytes: number): number {
32520 if(!isWasmInitialized) {
32521 throw new Error("initializeWasm() must be awaited first!");
32523 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes);
32524 return nativeResponseValue;
32526 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
32528 export function DefaultRouter_as_Router(this_arg: number): number {
32529 if(!isWasmInitialized) {
32530 throw new Error("initializeWasm() must be awaited first!");
32532 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
32533 return nativeResponseValue;
32535 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
32537 export function ChannelManager_as_Payer(this_arg: number): number {
32538 if(!isWasmInitialized) {
32539 throw new Error("initializeWasm() must be awaited first!");
32541 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
32542 return nativeResponseValue;
32544 // struct LDKCResult_SiPrefixParseErrorZ SiPrefix_from_str(struct LDKStr s);
32546 export function SiPrefix_from_str(s: number): number {
32547 if(!isWasmInitialized) {
32548 throw new Error("initializeWasm() must be awaited first!");
32550 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
32551 return nativeResponseValue;
32553 // struct LDKCResult_InvoiceParseOrSemanticErrorZ Invoice_from_str(struct LDKStr s);
32555 export function Invoice_from_str(s: number): number {
32556 if(!isWasmInitialized) {
32557 throw new Error("initializeWasm() must be awaited first!");
32559 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
32560 return nativeResponseValue;
32562 // struct LDKCResult_SignedRawInvoiceParseErrorZ SignedRawInvoice_from_str(struct LDKStr s);
32564 export function SignedRawInvoice_from_str(s: number): number {
32565 if(!isWasmInitialized) {
32566 throw new Error("initializeWasm() must be awaited first!");
32568 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
32569 return nativeResponseValue;
32571 // struct LDKStr ParseError_to_str(const struct LDKParseError *NONNULL_PTR o);
32573 export function ParseError_to_str(o: number): number {
32574 if(!isWasmInitialized) {
32575 throw new Error("initializeWasm() must be awaited first!");
32577 const nativeResponseValue = wasm.TS_ParseError_to_str(o);
32578 return nativeResponseValue;
32580 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
32582 export function ParseOrSemanticError_to_str(o: number): number {
32583 if(!isWasmInitialized) {
32584 throw new Error("initializeWasm() must be awaited first!");
32586 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
32587 return nativeResponseValue;
32589 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
32591 export function Invoice_to_str(o: number): number {
32592 if(!isWasmInitialized) {
32593 throw new Error("initializeWasm() must be awaited first!");
32595 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
32596 return nativeResponseValue;
32598 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
32600 export function SignedRawInvoice_to_str(o: number): number {
32601 if(!isWasmInitialized) {
32602 throw new Error("initializeWasm() must be awaited first!");
32604 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
32605 return nativeResponseValue;
32607 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
32609 export function Currency_to_str(o: number): number {
32610 if(!isWasmInitialized) {
32611 throw new Error("initializeWasm() must be awaited first!");
32613 const nativeResponseValue = wasm.TS_Currency_to_str(o);
32614 return nativeResponseValue;
32616 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
32618 export function SiPrefix_to_str(o: number): number {
32619 if(!isWasmInitialized) {
32620 throw new Error("initializeWasm() must be awaited first!");
32622 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
32623 return nativeResponseValue;
32627 js_invoke = function(obj_ptr: number, fn_id: number, arg1: number, arg2: number, arg3: number, arg4: number, arg5: number, arg6: number, arg7: number, arg8: number, arg9: number, arg10: number) {
32628 const weak: WeakRef<object> = js_objs[obj_ptr];
32629 if (weak == null || weak == undefined) {
32630 console.error("Got function call on unknown/free'd JS object!");
32631 throw new Error("Got function call on unknown/free'd JS object!");
32633 const obj: object = weak.deref();
32634 if (obj == null || obj == undefined) {
32635 console.error("Got function call on GC'd JS object!");
32636 throw new Error("Got function call on GC'd JS object!");
32640 case 0: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
32641 case 1: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
32642 case 2: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
32643 case 3: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
32644 case 4: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
32645 case 5: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
32646 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
32647 case 7: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
32648 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
32649 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
32650 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
32651 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
32652 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
32653 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
32654 case 14: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
32655 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
32656 case 16: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
32657 case 17: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
32658 case 18: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
32659 case 19: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
32660 case 20: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
32661 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
32662 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
32663 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
32664 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
32665 case 25: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
32666 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
32667 case 27: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
32668 case 28: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
32669 case 29: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
32670 case 30: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
32671 case 31: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
32672 case 32: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
32673 case 33: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
32674 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
32675 case 35: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
32676 case 36: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
32677 case 37: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
32678 case 38: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
32679 case 39: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
32680 case 40: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
32681 case 41: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
32682 case 42: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
32683 case 43: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
32684 case 44: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
32685 case 45: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
32686 case 46: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
32687 case 47: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
32688 case 48: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
32689 case 49: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
32690 case 50: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
32691 case 51: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
32692 case 52: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
32693 case 53: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
32694 case 54: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
32695 case 55: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
32696 case 56: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
32697 case 57: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
32698 case 58: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
32699 case 59: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
32700 case 60: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
32701 case 61: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
32702 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
32703 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
32704 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
32705 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
32706 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
32707 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
32708 case 68: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
32709 case 69: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
32710 case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
32711 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
32712 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
32713 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
32714 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
32715 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
32716 case 76: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcements"); break;
32717 case 77: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcements"); break;
32718 case 78: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
32719 case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
32720 case 80: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
32721 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
32722 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
32723 case 83: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
32724 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
32725 case 85: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
32726 case 86: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
32727 case 87: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
32728 case 88: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
32729 case 89: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
32730 case 90: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
32731 case 91: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
32732 case 92: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
32733 case 93: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
32734 case 94: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
32735 case 95: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
32736 case 96: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
32737 case 97: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
32739 console.error("Got unknown function call from C!");
32740 throw new Error("Got unknown function call from C!");
32742 if (fn == null || fn == undefined) {
32743 console.error("Got function call on incorrect JS object!");
32744 throw new Error("Got function call on incorrect JS object!");
32746 return fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);