2 import * as version from './version.mjs';
3 import { UInt5, WitnessVersion } from './structs/CommonBase.mjs';
5 const imports: any = {};
8 var js_objs: Array<WeakRef<object>> = [];
9 var js_invoke: Function;
10 var getRandomValues: Function;
12 imports.wasi_snapshot_preview1 = {
13 "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number) => {
14 // This should generally only be used to print panic messages
15 console.log("FD_WRITE to " + fd + " in " + iovec_array_len + " chunks.");
16 const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
17 for (var i = 0; i < iovec_array_len; i++) {
18 const bytes_view = new Uint8Array(wasm.memory.buffer, ptr_len_view[i*2], ptr_len_view[i*2+1]);
19 console.log(String.fromCharCode(...bytes_view));
23 "fd_close": (_fd: number) => {
24 // This is not generally called, but may be referenced in debug builds
25 console.log("wasi_snapshot_preview1:fd_close");
26 return 58; // Not Supported
28 "fd_seek": (_fd: number, _offset: bigint, _whence: number, _new_offset: number) => {
29 // This is not generally called, but may be referenced in debug builds
30 console.log("wasi_snapshot_preview1:fd_seek");
31 return 58; // Not Supported
33 "random_get": (buf_ptr: number, buf_len: number) => {
34 const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len);
38 "environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
39 // This is called before fd_write to format + print panic messages
40 console.log("wasi_snapshot_preview1:environ_sizes_get");
41 const out_count_view = new Uint32Array(wasm.memory.buffer, environ_var_count_ptr, 1);
42 out_count_view[0] = 0;
43 const out_len_view = new Uint32Array(wasm.memory.buffer, environ_len_ptr, 1);
47 "environ_get": (environ_ptr: number, environ_buf_ptr: number) => {
48 // This is called before fd_write to format + print panic messages
49 console.log("wasi_snapshot_preview1:environ_get");
50 return 58; // Note supported - we said there were 0 environment entries!
53 console.log("wasi_snapshot_preview1:proc_exit");
58 let isWasmInitialized: boolean = false;
60 async function finishInitializeWasm(wasmInstance: WebAssembly.Instance) {
61 if (typeof crypto === "undefined") {
62 var crypto_import = (await import('crypto')).webcrypto;
63 getRandomValues = crypto_import.getRandomValues.bind(crypto_import);
65 getRandomValues = crypto.getRandomValues.bind(crypto);
68 wasm = wasmInstance.exports;
69 if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) {
70 throw new Error("Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint");
73 if (decodeString(wasm.TS_get_lib_version_string()) !== version.get_ldk_java_bindings_version())
74 throw new Error("Compiled LDK library and LDK class files do not match");
75 // Fetching the LDK versions from C also checks that the header and binaries match
76 const c_bindings_ver: number = wasm.TS_get_ldk_c_bindings_version();
77 const ldk_ver: number = wasm.TS_get_ldk_version();
78 if (c_bindings_ver == 0)
79 throw new Error("LDK version did not match the header we built against");
81 throw new Error("LDK C bindings version did not match the header we built against");
82 const c_bindings_version: string = decodeString(c_bindings_ver)
83 const ldk_version: string = decodeString(ldk_ver);
84 console.log("Loaded LDK-Java Bindings with LDK " + ldk_version + " and LDK-C-Bindings " + c_bindings_version);
86 isWasmInitialized = true;
90 export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
91 imports.env["js_invoke_function_u"] = js_invoke;
92 imports.env["js_invoke_function_b"] = js_invoke;
93 const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
94 await finishInitializeWasm(wasmInstance);
98 export async function initializeWasmFetch(uri: string) {
99 const stream = fetch(uri);
100 imports.env["js_invoke_function_u"] = js_invoke;
101 imports.env["js_invoke_function_b"] = js_invoke;
102 const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
103 await finishInitializeWasm(wasmInstance);
108 export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
109 const arr = new Uint8Array(inputArray.length);
110 for (var i = 0; i < inputArray.length; i++) {
111 arr[i] = inputArray[i].getVal();
117 export function WitnessVersionArrToBytes(inputArray: Array<WitnessVersion>): Uint8Array {
118 const arr = new Uint8Array(inputArray.length);
119 for (var i = 0; i < inputArray.length; i++) {
120 arr[i] = inputArray[i].getVal();
128 export function encodeUint8Array (inputArray: Uint8Array): number {
129 const cArrayPointer = wasm.TS_malloc(inputArray.length + 4);
130 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
131 arrayLengthView[0] = inputArray.length;
132 const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
133 arrayMemoryView.set(inputArray);
134 return cArrayPointer;
137 export function encodeUint32Array (inputArray: Uint32Array|Array<number>): number {
138 const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 4);
139 const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer, inputArray.length);
140 arrayMemoryView.set(inputArray, 1);
141 arrayMemoryView[0] = inputArray.length;
142 return cArrayPointer;
145 export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>): number {
146 const cArrayPointer = wasm.TS_malloc(inputArray.length * 8 + 1);
147 const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
148 arrayLengthView[0] = inputArray.length;
149 const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
150 arrayMemoryView.set(inputArray);
151 return cArrayPointer;
155 export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {
156 if (arr.length != len) { throw new Error("Expected array of length " + len + "got " + arr.length); }
161 export function getArrayLength(arrayPointer: number): number {
162 const arraySizeViewer = new Uint32Array(wasm.memory.buffer, arrayPointer, 1);
163 return arraySizeViewer[0];
166 export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
167 const arraySize = getArrayLength(arrayPointer);
168 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, arraySize);
169 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
170 // will free the underlying memory when it becomes unreachable instead of copying here.
171 // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
172 const actualArray = actualArrayViewer.slice(0, arraySize);
174 wasm.TS_free(arrayPointer);
178 const decodeUint32Array = (arrayPointer: number, free = true) => {
179 const arraySize = getArrayLength(arrayPointer);
180 const actualArrayViewer = new Uint32Array(
181 wasm.memory.buffer, // value
182 arrayPointer + 4, // offset (ignoring length bytes)
183 arraySize // uint32 count
185 // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
186 // will free the underlying memory when it becomes unreachable instead of copying here.
187 const actualArray = actualArrayViewer.slice(0, arraySize);
189 wasm.TS_free(arrayPointer);
195 export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
198 export function getU32ArrayElem(arrayPointer: number, idx: number): number {
199 const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
200 return actualArrayViewer[idx];
204 export function getU8ArrayElem(arrayPointer: number, idx: number): number {
205 const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
206 return actualArrayViewer[idx];
211 export function encodeString(str: string): number {
212 const charArray = new TextEncoder().encode(str);
213 return encodeUint8Array(charArray);
217 export function decodeString(stringPointer: number, free = true): string {
218 const arraySize = getArrayLength(stringPointer);
219 const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 4, arraySize);
220 const result = new TextDecoder("utf-8").decode(memoryView);
223 wasm.TS_free(stringPointer);
229 /* @internal */ export function getRemainingAllocationCount(): number { return 0; }
230 /* @internal */ export function debugPrintRemainingAllocs() { }
233 export enum AccessError {
235 * The requested chain is unknown.
237 LDKAccessError_UnknownChain,
239 * The requested transaction doesn't exist or hasn't confirmed.
241 LDKAccessError_UnknownTx,
246 export enum COption_NoneZ {
248 * When we're in this state, this COption_NoneZ contains a
250 LDKCOption_NoneZ_Some,
252 * When we're in this state, this COption_NoneZ contains nothing
254 LDKCOption_NoneZ_None,
259 export enum ChannelMonitorUpdateErr {
261 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
262 our state failed, but is expected to succeed at some point in the future).
264 Such a failure will \"freeze\" a channel, preventing us from revoking old states or
265 submitting new commitment transactions to the counterparty. Once the update(s) that failed
266 have been successfully applied, a [`MonitorEvent::UpdateCompleted`] event should be returned
267 via [`Watch::release_pending_monitor_events`] which will then restore the channel to an
270 Note that a given ChannelManager will *never* re-generate a given ChannelMonitorUpdate. If
271 you return a TemporaryFailure you must ensure that it is written to disk safely before
272 writing out the latest ChannelManager state.
274 Even when a channel has been \"frozen\" updates to the ChannelMonitor can continue to occur
275 (eg if an inbound HTLC which we forwarded was claimed upstream resulting in us attempting
276 to claim it on this channel) and those updates must be applied wherever they can be. At
277 least one such updated ChannelMonitor must be persisted otherwise PermanentFailure should
278 be returned to get things on-chain ASAP using only the in-memory copy. Obviously updates to
279 the channel which would invalidate previous ChannelMonitors are not made when a channel has
282 Note that even if updates made after TemporaryFailure succeed you must still provide a
283 [`MonitorEvent::UpdateCompleted`] to ensure you have the latest monitor and re-enable
284 normal channel operation. Note that this is normally generated through a call to
285 [`ChainMonitor::channel_monitor_updated`].
287 Note that the update being processed here will not be replayed for you when you return a
288 [`MonitorEvent::UpdateCompleted`] event via [`Watch::release_pending_monitor_events`], so
289 you must store the update itself on your own local disk prior to returning a
290 TemporaryFailure. You may, of course, employ a journaling approach, storing only the
291 ChannelMonitorUpdate on disk without updating the monitor itself, replaying the journal at
294 For deployments where a copy of ChannelMonitors and other local state are backed up in a
295 remote location (with local copies persisted immediately), it is anticipated that all
296 updates will return TemporaryFailure until the remote copies could be updated.
298 [`ChainMonitor::channel_monitor_updated`]: chainmonitor::ChainMonitor::channel_monitor_updated
300 LDKChannelMonitorUpdateErr_TemporaryFailure,
302 * Used to indicate no further channel monitor updates will be allowed (eg we've moved on to a
303 different watchtower and cannot update with all watchtowers that were previously informed
306 At reception of this error, ChannelManager will force-close the channel and return at
307 least a final ChannelMonitorUpdate::ChannelForceClosed which must be delivered to at
308 least one ChannelMonitor copy. Revocation secret MUST NOT be released and offchain channel
309 update must be rejected.
311 This failure may also signal a failure to update the local persisted copy of one of
312 the channel monitor instance.
314 Note that even when you fail a holder commitment transaction update, you must store the
315 update to ensure you can claim from it in case of a duplicate copy of this ChannelMonitor
316 broadcasts it (e.g distributed channel-monitor deployment)
318 In case of distributed watchtowers deployment, the new version must be written to disk, as
319 state may have been stored but rejected due to a block forcing a commitment broadcast. This
320 storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
321 lagging behind on block processing.
323 LDKChannelMonitorUpdateErr_PermanentFailure,
328 export enum ConfirmationTarget {
330 * We are happy with this transaction confirming slowly when feerate drops some.
332 LDKConfirmationTarget_Background,
334 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
336 LDKConfirmationTarget_Normal,
338 * We'd like this transaction to confirm in the next few blocks.
340 LDKConfirmationTarget_HighPriority,
345 export enum CreationError {
347 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
349 LDKCreationError_DescriptionTooLong,
351 * The specified route has too many hops and can't be encoded
353 LDKCreationError_RouteTooLong,
355 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
357 LDKCreationError_TimestampOutOfBounds,
359 * The supplied millisatoshi amount was greater than the total bitcoin supply.
361 LDKCreationError_InvalidAmount,
363 * Route hints were required for this invoice and were missing. Applies to
366 [phantom invoices]: crate::utils::create_phantom_invoice
368 LDKCreationError_MissingRouteHints,
373 export enum Currency {
381 LDKCurrency_BitcoinTestnet,
398 export enum IOError {
400 LDKIOError_PermissionDenied,
401 LDKIOError_ConnectionRefused,
402 LDKIOError_ConnectionReset,
403 LDKIOError_ConnectionAborted,
404 LDKIOError_NotConnected,
405 LDKIOError_AddrInUse,
406 LDKIOError_AddrNotAvailable,
407 LDKIOError_BrokenPipe,
408 LDKIOError_AlreadyExists,
409 LDKIOError_WouldBlock,
410 LDKIOError_InvalidInput,
411 LDKIOError_InvalidData,
413 LDKIOError_WriteZero,
414 LDKIOError_Interrupted,
416 LDKIOError_UnexpectedEof,
423 * Designates extremely verbose information, including gossip-induced messages
427 * Designates very low priority, often extremely verbose, information
431 * Designates lower priority information
435 * Designates useful information
439 * Designates hazardous situations
443 * Designates very serious errors
450 export enum Network {
452 * The main Bitcoin blockchain.
456 * The testnet3 blockchain.
460 * A local test blockchain.
464 * A blockchain on which blocks are signed instead of mined.
471 export enum Recipient {
473 * The invoice should be signed with the local node secret key.
477 * The invoice should be signed with the phantom node secret key. This secret key must be the
478 same for all nodes participating in the [phantom node payment].
480 [phantom node payment]: PhantomKeysManager
482 LDKRecipient_PhantomNode,
487 export enum Secp256k1Error {
489 * Signature failed verification
491 LDKSecp256k1Error_IncorrectSignature,
493 * Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
495 LDKSecp256k1Error_InvalidMessage,
499 LDKSecp256k1Error_InvalidPublicKey,
503 LDKSecp256k1Error_InvalidSignature,
507 LDKSecp256k1Error_InvalidSecretKey,
511 LDKSecp256k1Error_InvalidSharedSecret,
515 LDKSecp256k1Error_InvalidRecoveryId,
517 * Invalid tweak for add_assign or mul_assign
519 LDKSecp256k1Error_InvalidTweak,
521 * Didn't pass enough memory to context creation with preallocated memory
523 LDKSecp256k1Error_NotEnoughMemory,
525 * Bad set of public keys.
527 LDKSecp256k1Error_InvalidPublicKeySum,
529 * The only valid parity values are 0 or 1.
531 LDKSecp256k1Error_InvalidParityValue,
536 export enum SemanticError {
538 * The invoice is missing the mandatory payment hash
540 LDKSemanticError_NoPaymentHash,
542 * The invoice has multiple payment hashes which isn't allowed
544 LDKSemanticError_MultiplePaymentHashes,
546 * No description or description hash are part of the invoice
548 LDKSemanticError_NoDescription,
550 * The invoice contains multiple descriptions and/or description hashes which isn't allowed
552 LDKSemanticError_MultipleDescriptions,
554 * The invoice is missing the mandatory payment secret, which all modern lightning nodes
557 LDKSemanticError_NoPaymentSecret,
559 * The invoice contains multiple payment secrets
561 LDKSemanticError_MultiplePaymentSecrets,
563 * The invoice's features are invalid
565 LDKSemanticError_InvalidFeatures,
567 * The recovery id doesn't fit the signature/pub key
569 LDKSemanticError_InvalidRecoveryId,
571 * The invoice's signature is invalid
573 LDKSemanticError_InvalidSignature,
575 * The invoice's amount was not a whole number of millisatoshis
577 LDKSemanticError_ImpreciseAmount,
582 export enum SiPrefix {
602 export class LDKBech32Error {
603 protected constructor() {}
606 export function LDKBech32Error_ty_from_ptr(ptr: number): number {
607 if(!isWasmInitialized) {
608 throw new Error("initializeWasm() must be awaited first!");
610 const nativeResponseValue = wasm.TS_LDKBech32Error_ty_from_ptr(ptr);
611 return nativeResponseValue;
614 export function LDKBech32Error_InvalidChar_get_invalid_char(ptr: number): number {
615 if(!isWasmInitialized) {
616 throw new Error("initializeWasm() must be awaited first!");
618 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidChar_get_invalid_char(ptr);
619 return nativeResponseValue;
622 export function LDKBech32Error_InvalidData_get_invalid_data(ptr: number): number {
623 if(!isWasmInitialized) {
624 throw new Error("initializeWasm() must be awaited first!");
626 const nativeResponseValue = wasm.TS_LDKBech32Error_InvalidData_get_invalid_data(ptr);
627 return nativeResponseValue;
629 // struct LDKCVec_u8Z TxOut_get_script_pubkey (struct LDKTxOut* thing)
631 export function TxOut_get_script_pubkey(thing: number): number {
632 if(!isWasmInitialized) {
633 throw new Error("initializeWasm() must be awaited first!");
635 const nativeResponseValue = wasm.TS_TxOut_get_script_pubkey(thing);
636 return nativeResponseValue;
638 // uint64_t TxOut_get_value (struct LDKTxOut* thing)
640 export function TxOut_get_value(thing: number): bigint {
641 if(!isWasmInitialized) {
642 throw new Error("initializeWasm() must be awaited first!");
644 const nativeResponseValue = wasm.TS_TxOut_get_value(thing);
645 return nativeResponseValue;
647 // void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
649 export function CResult_NoneNoneZ_get_ok(owner: number): void {
650 if(!isWasmInitialized) {
651 throw new Error("initializeWasm() must be awaited first!");
653 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_ok(owner);
654 // debug statements here
656 // void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner);
658 export function CResult_NoneNoneZ_get_err(owner: number): void {
659 if(!isWasmInitialized) {
660 throw new Error("initializeWasm() must be awaited first!");
662 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_get_err(owner);
663 // debug statements here
665 // struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
667 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner: number): number {
668 if(!isWasmInitialized) {
669 throw new Error("initializeWasm() must be awaited first!");
671 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner);
672 return nativeResponseValue;
674 // struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner);
676 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner: number): number {
677 if(!isWasmInitialized) {
678 throw new Error("initializeWasm() must be awaited first!");
680 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner);
681 return nativeResponseValue;
683 // struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
685 export function CResult_SecretKeyErrorZ_get_ok(owner: number): number {
686 if(!isWasmInitialized) {
687 throw new Error("initializeWasm() must be awaited first!");
689 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_ok(owner);
690 return nativeResponseValue;
692 // enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner);
694 export function CResult_SecretKeyErrorZ_get_err(owner: number): Secp256k1Error {
695 if(!isWasmInitialized) {
696 throw new Error("initializeWasm() must be awaited first!");
698 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_get_err(owner);
699 return nativeResponseValue;
701 // struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
703 export function CResult_PublicKeyErrorZ_get_ok(owner: number): number {
704 if(!isWasmInitialized) {
705 throw new Error("initializeWasm() must be awaited first!");
707 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_ok(owner);
708 return nativeResponseValue;
710 // enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner);
712 export function CResult_PublicKeyErrorZ_get_err(owner: number): Secp256k1Error {
713 if(!isWasmInitialized) {
714 throw new Error("initializeWasm() must be awaited first!");
716 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_get_err(owner);
717 return nativeResponseValue;
719 // struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
721 export function CResult_TxCreationKeysDecodeErrorZ_get_ok(owner: number): number {
722 if(!isWasmInitialized) {
723 throw new Error("initializeWasm() must be awaited first!");
725 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(owner);
726 return nativeResponseValue;
728 // struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner);
730 export function CResult_TxCreationKeysDecodeErrorZ_get_err(owner: number): number {
731 if(!isWasmInitialized) {
732 throw new Error("initializeWasm() must be awaited first!");
734 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_get_err(owner);
735 return nativeResponseValue;
737 // struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
739 export function CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner: number): number {
740 if(!isWasmInitialized) {
741 throw new Error("initializeWasm() must be awaited first!");
743 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner);
744 return nativeResponseValue;
746 // struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner);
748 export function CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner: number): number {
749 if(!isWasmInitialized) {
750 throw new Error("initializeWasm() must be awaited first!");
752 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner);
753 return nativeResponseValue;
755 // struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
757 export function CResult_TxCreationKeysErrorZ_get_ok(owner: number): number {
758 if(!isWasmInitialized) {
759 throw new Error("initializeWasm() must be awaited first!");
761 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_ok(owner);
762 return nativeResponseValue;
764 // enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner);
766 export function CResult_TxCreationKeysErrorZ_get_err(owner: number): Secp256k1Error {
767 if(!isWasmInitialized) {
768 throw new Error("initializeWasm() must be awaited first!");
770 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_get_err(owner);
771 return nativeResponseValue;
774 export class LDKCOption_u32Z {
775 protected constructor() {}
778 export function LDKCOption_u32Z_ty_from_ptr(ptr: number): number {
779 if(!isWasmInitialized) {
780 throw new Error("initializeWasm() must be awaited first!");
782 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_ty_from_ptr(ptr);
783 return nativeResponseValue;
786 export function LDKCOption_u32Z_Some_get_some(ptr: number): number {
787 if(!isWasmInitialized) {
788 throw new Error("initializeWasm() must be awaited first!");
790 const nativeResponseValue = wasm.TS_LDKCOption_u32Z_Some_get_some(ptr);
791 return nativeResponseValue;
793 // struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
795 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner: number): number {
796 if(!isWasmInitialized) {
797 throw new Error("initializeWasm() must be awaited first!");
799 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner);
800 return nativeResponseValue;
802 // struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner);
804 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner: number): number {
805 if(!isWasmInitialized) {
806 throw new Error("initializeWasm() must be awaited first!");
808 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner);
809 return nativeResponseValue;
811 // struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
813 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
814 if(!isWasmInitialized) {
815 throw new Error("initializeWasm() must be awaited first!");
817 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner);
818 return nativeResponseValue;
820 // struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
822 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
823 if(!isWasmInitialized) {
824 throw new Error("initializeWasm() must be awaited first!");
826 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner);
827 return nativeResponseValue;
829 // struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
831 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner: number): number {
832 if(!isWasmInitialized) {
833 throw new Error("initializeWasm() must be awaited first!");
835 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner);
836 return nativeResponseValue;
838 // struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner);
840 export function CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner: number): number {
841 if(!isWasmInitialized) {
842 throw new Error("initializeWasm() must be awaited first!");
844 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner);
845 return nativeResponseValue;
847 // struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
849 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
850 if(!isWasmInitialized) {
851 throw new Error("initializeWasm() must be awaited first!");
853 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner);
854 return nativeResponseValue;
856 // struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
858 export function CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
859 if(!isWasmInitialized) {
860 throw new Error("initializeWasm() must be awaited first!");
862 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner);
863 return nativeResponseValue;
865 // struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
867 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
868 if(!isWasmInitialized) {
869 throw new Error("initializeWasm() must be awaited first!");
871 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner);
872 return nativeResponseValue;
874 // struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
876 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
877 if(!isWasmInitialized) {
878 throw new Error("initializeWasm() must be awaited first!");
880 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner);
881 return nativeResponseValue;
883 // struct LDKTrustedClosingTransaction *CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
885 export function CResult_TrustedClosingTransactionNoneZ_get_ok(owner: number): number {
886 if(!isWasmInitialized) {
887 throw new Error("initializeWasm() must be awaited first!");
889 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_ok(owner);
890 return nativeResponseValue;
892 // void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner);
894 export function CResult_TrustedClosingTransactionNoneZ_get_err(owner: number): void {
895 if(!isWasmInitialized) {
896 throw new Error("initializeWasm() must be awaited first!");
898 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_get_err(owner);
899 // debug statements here
901 // struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
903 export function CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner: number): number {
904 if(!isWasmInitialized) {
905 throw new Error("initializeWasm() must be awaited first!");
907 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner);
908 return nativeResponseValue;
910 // struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner);
912 export function CResult_CommitmentTransactionDecodeErrorZ_get_err(owner: number): number {
913 if(!isWasmInitialized) {
914 throw new Error("initializeWasm() must be awaited first!");
916 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(owner);
917 return nativeResponseValue;
919 // struct LDKTrustedCommitmentTransaction *CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
921 export function CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner: number): number {
922 if(!isWasmInitialized) {
923 throw new Error("initializeWasm() must be awaited first!");
925 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner);
926 return nativeResponseValue;
928 // void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner);
930 export function CResult_TrustedCommitmentTransactionNoneZ_get_err(owner: number): void {
931 if(!isWasmInitialized) {
932 throw new Error("initializeWasm() must be awaited first!");
934 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(owner);
935 // debug statements here
937 // struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
939 export function CResult_CVec_SignatureZNoneZ_get_ok(owner: number): number {
940 if(!isWasmInitialized) {
941 throw new Error("initializeWasm() must be awaited first!");
943 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_ok(owner);
944 return nativeResponseValue;
946 // void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner);
948 export function CResult_CVec_SignatureZNoneZ_get_err(owner: number): void {
949 if(!isWasmInitialized) {
950 throw new Error("initializeWasm() must be awaited first!");
952 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_get_err(owner);
953 // debug statements here
955 // struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
957 export function CResult_ShutdownScriptDecodeErrorZ_get_ok(owner: number): number {
958 if(!isWasmInitialized) {
959 throw new Error("initializeWasm() must be awaited first!");
961 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(owner);
962 return nativeResponseValue;
964 // struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner);
966 export function CResult_ShutdownScriptDecodeErrorZ_get_err(owner: number): number {
967 if(!isWasmInitialized) {
968 throw new Error("initializeWasm() must be awaited first!");
970 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_get_err(owner);
971 return nativeResponseValue;
973 // struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
975 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner: number): number {
976 if(!isWasmInitialized) {
977 throw new Error("initializeWasm() must be awaited first!");
979 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner);
980 return nativeResponseValue;
982 // struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner);
984 export function CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner: number): number {
985 if(!isWasmInitialized) {
986 throw new Error("initializeWasm() must be awaited first!");
988 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner);
989 return nativeResponseValue;
991 // struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
993 export function CResult_RouteHopDecodeErrorZ_get_ok(owner: number): number {
994 if(!isWasmInitialized) {
995 throw new Error("initializeWasm() must be awaited first!");
997 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_ok(owner);
998 return nativeResponseValue;
1000 // struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner);
1002 export function CResult_RouteHopDecodeErrorZ_get_err(owner: number): number {
1003 if(!isWasmInitialized) {
1004 throw new Error("initializeWasm() must be awaited first!");
1006 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_get_err(owner);
1007 return nativeResponseValue;
1009 // struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1011 export function CResult_RouteDecodeErrorZ_get_ok(owner: number): number {
1012 if(!isWasmInitialized) {
1013 throw new Error("initializeWasm() must be awaited first!");
1015 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_ok(owner);
1016 return nativeResponseValue;
1018 // struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner);
1020 export function CResult_RouteDecodeErrorZ_get_err(owner: number): number {
1021 if(!isWasmInitialized) {
1022 throw new Error("initializeWasm() must be awaited first!");
1024 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_get_err(owner);
1025 return nativeResponseValue;
1027 // struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1029 export function CResult_RouteParametersDecodeErrorZ_get_ok(owner: number): number {
1030 if(!isWasmInitialized) {
1031 throw new Error("initializeWasm() must be awaited first!");
1033 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_ok(owner);
1034 return nativeResponseValue;
1036 // struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner);
1038 export function CResult_RouteParametersDecodeErrorZ_get_err(owner: number): number {
1039 if(!isWasmInitialized) {
1040 throw new Error("initializeWasm() must be awaited first!");
1042 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_get_err(owner);
1043 return nativeResponseValue;
1046 export class LDKCOption_u64Z {
1047 protected constructor() {}
1050 export function LDKCOption_u64Z_ty_from_ptr(ptr: number): number {
1051 if(!isWasmInitialized) {
1052 throw new Error("initializeWasm() must be awaited first!");
1054 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_ty_from_ptr(ptr);
1055 return nativeResponseValue;
1058 export function LDKCOption_u64Z_Some_get_some(ptr: number): bigint {
1059 if(!isWasmInitialized) {
1060 throw new Error("initializeWasm() must be awaited first!");
1062 const nativeResponseValue = wasm.TS_LDKCOption_u64Z_Some_get_some(ptr);
1063 return nativeResponseValue;
1065 // struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1067 export function CResult_PaymentParametersDecodeErrorZ_get_ok(owner: number): number {
1068 if(!isWasmInitialized) {
1069 throw new Error("initializeWasm() must be awaited first!");
1071 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_ok(owner);
1072 return nativeResponseValue;
1074 // struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner);
1076 export function CResult_PaymentParametersDecodeErrorZ_get_err(owner: number): number {
1077 if(!isWasmInitialized) {
1078 throw new Error("initializeWasm() must be awaited first!");
1080 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_get_err(owner);
1081 return nativeResponseValue;
1083 // struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1085 export function CResult_RouteHintDecodeErrorZ_get_ok(owner: number): number {
1086 if(!isWasmInitialized) {
1087 throw new Error("initializeWasm() must be awaited first!");
1089 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_ok(owner);
1090 return nativeResponseValue;
1092 // struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner);
1094 export function CResult_RouteHintDecodeErrorZ_get_err(owner: number): number {
1095 if(!isWasmInitialized) {
1096 throw new Error("initializeWasm() must be awaited first!");
1098 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_get_err(owner);
1099 return nativeResponseValue;
1101 // struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1103 export function CResult_RouteHintHopDecodeErrorZ_get_ok(owner: number): number {
1104 if(!isWasmInitialized) {
1105 throw new Error("initializeWasm() must be awaited first!");
1107 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_ok(owner);
1108 return nativeResponseValue;
1110 // struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner);
1112 export function CResult_RouteHintHopDecodeErrorZ_get_err(owner: number): number {
1113 if(!isWasmInitialized) {
1114 throw new Error("initializeWasm() must be awaited first!");
1116 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_get_err(owner);
1117 return nativeResponseValue;
1119 // struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1121 export function CResult_RouteLightningErrorZ_get_ok(owner: number): number {
1122 if(!isWasmInitialized) {
1123 throw new Error("initializeWasm() must be awaited first!");
1125 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_ok(owner);
1126 return nativeResponseValue;
1128 // struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner);
1130 export function CResult_RouteLightningErrorZ_get_err(owner: number): number {
1131 if(!isWasmInitialized) {
1132 throw new Error("initializeWasm() must be awaited first!");
1134 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_get_err(owner);
1135 return nativeResponseValue;
1138 export class LDKPaymentPurpose {
1139 protected constructor() {}
1142 export function LDKPaymentPurpose_ty_from_ptr(ptr: number): number {
1143 if(!isWasmInitialized) {
1144 throw new Error("initializeWasm() must be awaited first!");
1146 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_ty_from_ptr(ptr);
1147 return nativeResponseValue;
1150 export function LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr: number): number {
1151 if(!isWasmInitialized) {
1152 throw new Error("initializeWasm() must be awaited first!");
1154 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(ptr);
1155 return nativeResponseValue;
1158 export function LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr: number): number {
1159 if(!isWasmInitialized) {
1160 throw new Error("initializeWasm() must be awaited first!");
1162 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(ptr);
1163 return nativeResponseValue;
1166 export function LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr: number): number {
1167 if(!isWasmInitialized) {
1168 throw new Error("initializeWasm() must be awaited first!");
1170 const nativeResponseValue = wasm.TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(ptr);
1171 return nativeResponseValue;
1173 // struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1175 export function CResult_PaymentPurposeDecodeErrorZ_get_ok(owner: number): number {
1176 if(!isWasmInitialized) {
1177 throw new Error("initializeWasm() must be awaited first!");
1179 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(owner);
1180 return nativeResponseValue;
1182 // struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner);
1184 export function CResult_PaymentPurposeDecodeErrorZ_get_err(owner: number): number {
1185 if(!isWasmInitialized) {
1186 throw new Error("initializeWasm() must be awaited first!");
1188 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_get_err(owner);
1189 return nativeResponseValue;
1192 export class LDKClosureReason {
1193 protected constructor() {}
1196 export function LDKClosureReason_ty_from_ptr(ptr: number): number {
1197 if(!isWasmInitialized) {
1198 throw new Error("initializeWasm() must be awaited first!");
1200 const nativeResponseValue = wasm.TS_LDKClosureReason_ty_from_ptr(ptr);
1201 return nativeResponseValue;
1204 export function LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr: number): number {
1205 if(!isWasmInitialized) {
1206 throw new Error("initializeWasm() must be awaited first!");
1208 const nativeResponseValue = wasm.TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
1209 return nativeResponseValue;
1212 export function LDKClosureReason_ProcessingError_get_err(ptr: number): number {
1213 if(!isWasmInitialized) {
1214 throw new Error("initializeWasm() must be awaited first!");
1216 const nativeResponseValue = wasm.TS_LDKClosureReason_ProcessingError_get_err(ptr);
1217 return nativeResponseValue;
1220 export class LDKCOption_ClosureReasonZ {
1221 protected constructor() {}
1224 export function LDKCOption_ClosureReasonZ_ty_from_ptr(ptr: number): number {
1225 if(!isWasmInitialized) {
1226 throw new Error("initializeWasm() must be awaited first!");
1228 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_ty_from_ptr(ptr);
1229 return nativeResponseValue;
1232 export function LDKCOption_ClosureReasonZ_Some_get_some(ptr: number): number {
1233 if(!isWasmInitialized) {
1234 throw new Error("initializeWasm() must be awaited first!");
1236 const nativeResponseValue = wasm.TS_LDKCOption_ClosureReasonZ_Some_get_some(ptr);
1237 return nativeResponseValue;
1239 // struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1241 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner: number): number {
1242 if(!isWasmInitialized) {
1243 throw new Error("initializeWasm() must be awaited first!");
1245 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner);
1246 return nativeResponseValue;
1248 // struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner);
1250 export function CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner: number): number {
1251 if(!isWasmInitialized) {
1252 throw new Error("initializeWasm() must be awaited first!");
1254 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner);
1255 return nativeResponseValue;
1258 export class LDKNetworkUpdate {
1259 protected constructor() {}
1262 export function LDKNetworkUpdate_ty_from_ptr(ptr: number): number {
1263 if(!isWasmInitialized) {
1264 throw new Error("initializeWasm() must be awaited first!");
1266 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ty_from_ptr(ptr);
1267 return nativeResponseValue;
1270 export function LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr: number): number {
1271 if(!isWasmInitialized) {
1272 throw new Error("initializeWasm() must be awaited first!");
1274 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(ptr);
1275 return nativeResponseValue;
1278 export function LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr: number): bigint {
1279 if(!isWasmInitialized) {
1280 throw new Error("initializeWasm() must be awaited first!");
1282 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(ptr);
1283 return nativeResponseValue;
1286 export function LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr: number): boolean {
1287 if(!isWasmInitialized) {
1288 throw new Error("initializeWasm() must be awaited first!");
1290 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(ptr);
1291 return nativeResponseValue;
1294 export function LDKNetworkUpdate_NodeFailure_get_node_id(ptr: number): number {
1295 if(!isWasmInitialized) {
1296 throw new Error("initializeWasm() must be awaited first!");
1298 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_node_id(ptr);
1299 return nativeResponseValue;
1302 export function LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr: number): boolean {
1303 if(!isWasmInitialized) {
1304 throw new Error("initializeWasm() must be awaited first!");
1306 const nativeResponseValue = wasm.TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(ptr);
1307 return nativeResponseValue;
1310 export class LDKCOption_NetworkUpdateZ {
1311 protected constructor() {}
1314 export function LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr: number): number {
1315 if(!isWasmInitialized) {
1316 throw new Error("initializeWasm() must be awaited first!");
1318 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(ptr);
1319 return nativeResponseValue;
1322 export function LDKCOption_NetworkUpdateZ_Some_get_some(ptr: number): number {
1323 if(!isWasmInitialized) {
1324 throw new Error("initializeWasm() must be awaited first!");
1326 const nativeResponseValue = wasm.TS_LDKCOption_NetworkUpdateZ_Some_get_some(ptr);
1327 return nativeResponseValue;
1330 export class LDKSpendableOutputDescriptor {
1331 protected constructor() {}
1334 export function LDKSpendableOutputDescriptor_ty_from_ptr(ptr: number): number {
1335 if(!isWasmInitialized) {
1336 throw new Error("initializeWasm() must be awaited first!");
1338 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_ty_from_ptr(ptr);
1339 return nativeResponseValue;
1342 export function LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr: number): number {
1343 if(!isWasmInitialized) {
1344 throw new Error("initializeWasm() must be awaited first!");
1346 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(ptr);
1347 return nativeResponseValue;
1350 export function LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr: number): number {
1351 if(!isWasmInitialized) {
1352 throw new Error("initializeWasm() must be awaited first!");
1354 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(ptr);
1355 return nativeResponseValue;
1358 export function LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr: number): number {
1359 if(!isWasmInitialized) {
1360 throw new Error("initializeWasm() must be awaited first!");
1362 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(ptr);
1363 return nativeResponseValue;
1366 export function LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr: number): number {
1367 if(!isWasmInitialized) {
1368 throw new Error("initializeWasm() must be awaited first!");
1370 const nativeResponseValue = wasm.TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(ptr);
1371 return nativeResponseValue;
1374 export class LDKEvent {
1375 protected constructor() {}
1378 export function LDKEvent_ty_from_ptr(ptr: number): number {
1379 if(!isWasmInitialized) {
1380 throw new Error("initializeWasm() must be awaited first!");
1382 const nativeResponseValue = wasm.TS_LDKEvent_ty_from_ptr(ptr);
1383 return nativeResponseValue;
1386 export function LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr: number): number {
1387 if(!isWasmInitialized) {
1388 throw new Error("initializeWasm() must be awaited first!");
1390 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(ptr);
1391 return nativeResponseValue;
1394 export function LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr: number): number {
1395 if(!isWasmInitialized) {
1396 throw new Error("initializeWasm() must be awaited first!");
1398 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(ptr);
1399 return nativeResponseValue;
1402 export function LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr: number): bigint {
1403 if(!isWasmInitialized) {
1404 throw new Error("initializeWasm() must be awaited first!");
1406 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(ptr);
1407 return nativeResponseValue;
1410 export function LDKEvent_FundingGenerationReady_get_output_script(ptr: number): number {
1411 if(!isWasmInitialized) {
1412 throw new Error("initializeWasm() must be awaited first!");
1414 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_output_script(ptr);
1415 return nativeResponseValue;
1418 export function LDKEvent_FundingGenerationReady_get_user_channel_id(ptr: number): bigint {
1419 if(!isWasmInitialized) {
1420 throw new Error("initializeWasm() must be awaited first!");
1422 const nativeResponseValue = wasm.TS_LDKEvent_FundingGenerationReady_get_user_channel_id(ptr);
1423 return nativeResponseValue;
1426 export function LDKEvent_PaymentReceived_get_payment_hash(ptr: number): number {
1427 if(!isWasmInitialized) {
1428 throw new Error("initializeWasm() must be awaited first!");
1430 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_payment_hash(ptr);
1431 return nativeResponseValue;
1434 export function LDKEvent_PaymentReceived_get_amount_msat(ptr: number): bigint {
1435 if(!isWasmInitialized) {
1436 throw new Error("initializeWasm() must be awaited first!");
1438 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_amount_msat(ptr);
1439 return nativeResponseValue;
1442 export function LDKEvent_PaymentReceived_get_purpose(ptr: number): number {
1443 if(!isWasmInitialized) {
1444 throw new Error("initializeWasm() must be awaited first!");
1446 const nativeResponseValue = wasm.TS_LDKEvent_PaymentReceived_get_purpose(ptr);
1447 return nativeResponseValue;
1450 export function LDKEvent_PaymentClaimed_get_payment_hash(ptr: number): number {
1451 if(!isWasmInitialized) {
1452 throw new Error("initializeWasm() must be awaited first!");
1454 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_payment_hash(ptr);
1455 return nativeResponseValue;
1458 export function LDKEvent_PaymentClaimed_get_amount_msat(ptr: number): bigint {
1459 if(!isWasmInitialized) {
1460 throw new Error("initializeWasm() must be awaited first!");
1462 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_amount_msat(ptr);
1463 return nativeResponseValue;
1466 export function LDKEvent_PaymentClaimed_get_purpose(ptr: number): number {
1467 if(!isWasmInitialized) {
1468 throw new Error("initializeWasm() must be awaited first!");
1470 const nativeResponseValue = wasm.TS_LDKEvent_PaymentClaimed_get_purpose(ptr);
1471 return nativeResponseValue;
1474 export function LDKEvent_PaymentSent_get_payment_id(ptr: number): number {
1475 if(!isWasmInitialized) {
1476 throw new Error("initializeWasm() must be awaited first!");
1478 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_id(ptr);
1479 return nativeResponseValue;
1482 export function LDKEvent_PaymentSent_get_payment_preimage(ptr: number): number {
1483 if(!isWasmInitialized) {
1484 throw new Error("initializeWasm() must be awaited first!");
1486 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_preimage(ptr);
1487 return nativeResponseValue;
1490 export function LDKEvent_PaymentSent_get_payment_hash(ptr: number): number {
1491 if(!isWasmInitialized) {
1492 throw new Error("initializeWasm() must be awaited first!");
1494 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_payment_hash(ptr);
1495 return nativeResponseValue;
1498 export function LDKEvent_PaymentSent_get_fee_paid_msat(ptr: number): number {
1499 if(!isWasmInitialized) {
1500 throw new Error("initializeWasm() must be awaited first!");
1502 const nativeResponseValue = wasm.TS_LDKEvent_PaymentSent_get_fee_paid_msat(ptr);
1503 return nativeResponseValue;
1506 export function LDKEvent_PaymentFailed_get_payment_id(ptr: number): number {
1507 if(!isWasmInitialized) {
1508 throw new Error("initializeWasm() must be awaited first!");
1510 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_id(ptr);
1511 return nativeResponseValue;
1514 export function LDKEvent_PaymentFailed_get_payment_hash(ptr: number): number {
1515 if(!isWasmInitialized) {
1516 throw new Error("initializeWasm() must be awaited first!");
1518 const nativeResponseValue = wasm.TS_LDKEvent_PaymentFailed_get_payment_hash(ptr);
1519 return nativeResponseValue;
1522 export function LDKEvent_PaymentPathSuccessful_get_payment_id(ptr: number): number {
1523 if(!isWasmInitialized) {
1524 throw new Error("initializeWasm() must be awaited first!");
1526 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_id(ptr);
1527 return nativeResponseValue;
1530 export function LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr: number): number {
1531 if(!isWasmInitialized) {
1532 throw new Error("initializeWasm() must be awaited first!");
1534 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(ptr);
1535 return nativeResponseValue;
1538 export function LDKEvent_PaymentPathSuccessful_get_path(ptr: number): number {
1539 if(!isWasmInitialized) {
1540 throw new Error("initializeWasm() must be awaited first!");
1542 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathSuccessful_get_path(ptr);
1543 return nativeResponseValue;
1546 export function LDKEvent_PaymentPathFailed_get_payment_id(ptr: number): number {
1547 if(!isWasmInitialized) {
1548 throw new Error("initializeWasm() must be awaited first!");
1550 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_id(ptr);
1551 return nativeResponseValue;
1554 export function LDKEvent_PaymentPathFailed_get_payment_hash(ptr: number): number {
1555 if(!isWasmInitialized) {
1556 throw new Error("initializeWasm() must be awaited first!");
1558 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_payment_hash(ptr);
1559 return nativeResponseValue;
1562 export function LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr: number): boolean {
1563 if(!isWasmInitialized) {
1564 throw new Error("initializeWasm() must be awaited first!");
1566 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest(ptr);
1567 return nativeResponseValue;
1570 export function LDKEvent_PaymentPathFailed_get_network_update(ptr: number): number {
1571 if(!isWasmInitialized) {
1572 throw new Error("initializeWasm() must be awaited first!");
1574 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_network_update(ptr);
1575 return nativeResponseValue;
1578 export function LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr: number): boolean {
1579 if(!isWasmInitialized) {
1580 throw new Error("initializeWasm() must be awaited first!");
1582 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(ptr);
1583 return nativeResponseValue;
1586 export function LDKEvent_PaymentPathFailed_get_path(ptr: number): number {
1587 if(!isWasmInitialized) {
1588 throw new Error("initializeWasm() must be awaited first!");
1590 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_path(ptr);
1591 return nativeResponseValue;
1594 export function LDKEvent_PaymentPathFailed_get_short_channel_id(ptr: number): number {
1595 if(!isWasmInitialized) {
1596 throw new Error("initializeWasm() must be awaited first!");
1598 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_short_channel_id(ptr);
1599 return nativeResponseValue;
1602 export function LDKEvent_PaymentPathFailed_get_retry(ptr: number): number {
1603 if(!isWasmInitialized) {
1604 throw new Error("initializeWasm() must be awaited first!");
1606 const nativeResponseValue = wasm.TS_LDKEvent_PaymentPathFailed_get_retry(ptr);
1607 return nativeResponseValue;
1610 export function LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr: number): bigint {
1611 if(!isWasmInitialized) {
1612 throw new Error("initializeWasm() must be awaited first!");
1614 const nativeResponseValue = wasm.TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(ptr);
1615 return nativeResponseValue;
1618 export function LDKEvent_SpendableOutputs_get_outputs(ptr: number): number {
1619 if(!isWasmInitialized) {
1620 throw new Error("initializeWasm() must be awaited first!");
1622 const nativeResponseValue = wasm.TS_LDKEvent_SpendableOutputs_get_outputs(ptr);
1623 return nativeResponseValue;
1626 export function LDKEvent_PaymentForwarded_get_prev_channel_id(ptr: number): number {
1627 if(!isWasmInitialized) {
1628 throw new Error("initializeWasm() must be awaited first!");
1630 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_prev_channel_id(ptr);
1631 return nativeResponseValue;
1634 export function LDKEvent_PaymentForwarded_get_next_channel_id(ptr: number): number {
1635 if(!isWasmInitialized) {
1636 throw new Error("initializeWasm() must be awaited first!");
1638 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_next_channel_id(ptr);
1639 return nativeResponseValue;
1642 export function LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr: number): number {
1643 if(!isWasmInitialized) {
1644 throw new Error("initializeWasm() must be awaited first!");
1646 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(ptr);
1647 return nativeResponseValue;
1650 export function LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr: number): boolean {
1651 if(!isWasmInitialized) {
1652 throw new Error("initializeWasm() must be awaited first!");
1654 const nativeResponseValue = wasm.TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(ptr);
1655 return nativeResponseValue;
1658 export function LDKEvent_ChannelClosed_get_channel_id(ptr: number): number {
1659 if(!isWasmInitialized) {
1660 throw new Error("initializeWasm() must be awaited first!");
1662 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_channel_id(ptr);
1663 return nativeResponseValue;
1666 export function LDKEvent_ChannelClosed_get_user_channel_id(ptr: number): bigint {
1667 if(!isWasmInitialized) {
1668 throw new Error("initializeWasm() must be awaited first!");
1670 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_user_channel_id(ptr);
1671 return nativeResponseValue;
1674 export function LDKEvent_ChannelClosed_get_reason(ptr: number): number {
1675 if(!isWasmInitialized) {
1676 throw new Error("initializeWasm() must be awaited first!");
1678 const nativeResponseValue = wasm.TS_LDKEvent_ChannelClosed_get_reason(ptr);
1679 return nativeResponseValue;
1682 export function LDKEvent_DiscardFunding_get_channel_id(ptr: number): number {
1683 if(!isWasmInitialized) {
1684 throw new Error("initializeWasm() must be awaited first!");
1686 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_channel_id(ptr);
1687 return nativeResponseValue;
1690 export function LDKEvent_DiscardFunding_get_transaction(ptr: number): number {
1691 if(!isWasmInitialized) {
1692 throw new Error("initializeWasm() must be awaited first!");
1694 const nativeResponseValue = wasm.TS_LDKEvent_DiscardFunding_get_transaction(ptr);
1695 return nativeResponseValue;
1698 export function LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr: number): number {
1699 if(!isWasmInitialized) {
1700 throw new Error("initializeWasm() must be awaited first!");
1702 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(ptr);
1703 return nativeResponseValue;
1706 export function LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr: number): number {
1707 if(!isWasmInitialized) {
1708 throw new Error("initializeWasm() must be awaited first!");
1710 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(ptr);
1711 return nativeResponseValue;
1714 export function LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr: number): bigint {
1715 if(!isWasmInitialized) {
1716 throw new Error("initializeWasm() must be awaited first!");
1718 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(ptr);
1719 return nativeResponseValue;
1722 export function LDKEvent_OpenChannelRequest_get_push_msat(ptr: number): bigint {
1723 if(!isWasmInitialized) {
1724 throw new Error("initializeWasm() must be awaited first!");
1726 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_push_msat(ptr);
1727 return nativeResponseValue;
1730 export function LDKEvent_OpenChannelRequest_get_channel_type(ptr: number): number {
1731 if(!isWasmInitialized) {
1732 throw new Error("initializeWasm() must be awaited first!");
1734 const nativeResponseValue = wasm.TS_LDKEvent_OpenChannelRequest_get_channel_type(ptr);
1735 return nativeResponseValue;
1738 export class LDKCOption_EventZ {
1739 protected constructor() {}
1742 export function LDKCOption_EventZ_ty_from_ptr(ptr: number): number {
1743 if(!isWasmInitialized) {
1744 throw new Error("initializeWasm() must be awaited first!");
1746 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_ty_from_ptr(ptr);
1747 return nativeResponseValue;
1750 export function LDKCOption_EventZ_Some_get_some(ptr: number): number {
1751 if(!isWasmInitialized) {
1752 throw new Error("initializeWasm() must be awaited first!");
1754 const nativeResponseValue = wasm.TS_LDKCOption_EventZ_Some_get_some(ptr);
1755 return nativeResponseValue;
1757 // struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1759 export function CResult_COption_EventZDecodeErrorZ_get_ok(owner: number): number {
1760 if(!isWasmInitialized) {
1761 throw new Error("initializeWasm() must be awaited first!");
1763 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_ok(owner);
1764 return nativeResponseValue;
1766 // struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner);
1768 export function CResult_COption_EventZDecodeErrorZ_get_err(owner: number): number {
1769 if(!isWasmInitialized) {
1770 throw new Error("initializeWasm() must be awaited first!");
1772 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_get_err(owner);
1773 return nativeResponseValue;
1776 export class LDKErrorAction {
1777 protected constructor() {}
1780 export function LDKErrorAction_ty_from_ptr(ptr: number): number {
1781 if(!isWasmInitialized) {
1782 throw new Error("initializeWasm() must be awaited first!");
1784 const nativeResponseValue = wasm.TS_LDKErrorAction_ty_from_ptr(ptr);
1785 return nativeResponseValue;
1788 export function LDKErrorAction_DisconnectPeer_get_msg(ptr: number): number {
1789 if(!isWasmInitialized) {
1790 throw new Error("initializeWasm() must be awaited first!");
1792 const nativeResponseValue = wasm.TS_LDKErrorAction_DisconnectPeer_get_msg(ptr);
1793 return nativeResponseValue;
1796 export function LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr: number): Level {
1797 if(!isWasmInitialized) {
1798 throw new Error("initializeWasm() must be awaited first!");
1800 const nativeResponseValue = wasm.TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(ptr);
1801 return nativeResponseValue;
1804 export function LDKErrorAction_SendErrorMessage_get_msg(ptr: number): number {
1805 if(!isWasmInitialized) {
1806 throw new Error("initializeWasm() must be awaited first!");
1808 const nativeResponseValue = wasm.TS_LDKErrorAction_SendErrorMessage_get_msg(ptr);
1809 return nativeResponseValue;
1812 export function LDKErrorAction_SendWarningMessage_get_msg(ptr: number): number {
1813 if(!isWasmInitialized) {
1814 throw new Error("initializeWasm() must be awaited first!");
1816 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_msg(ptr);
1817 return nativeResponseValue;
1820 export function LDKErrorAction_SendWarningMessage_get_log_level(ptr: number): Level {
1821 if(!isWasmInitialized) {
1822 throw new Error("initializeWasm() must be awaited first!");
1824 const nativeResponseValue = wasm.TS_LDKErrorAction_SendWarningMessage_get_log_level(ptr);
1825 return nativeResponseValue;
1828 export class LDKMessageSendEvent {
1829 protected constructor() {}
1832 export function LDKMessageSendEvent_ty_from_ptr(ptr: number): number {
1833 if(!isWasmInitialized) {
1834 throw new Error("initializeWasm() must be awaited first!");
1836 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_ty_from_ptr(ptr);
1837 return nativeResponseValue;
1840 export function LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr: number): number {
1841 if(!isWasmInitialized) {
1842 throw new Error("initializeWasm() must be awaited first!");
1844 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
1845 return nativeResponseValue;
1848 export function LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr: number): number {
1849 if(!isWasmInitialized) {
1850 throw new Error("initializeWasm() must be awaited first!");
1852 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
1853 return nativeResponseValue;
1856 export function LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr: number): number {
1857 if(!isWasmInitialized) {
1858 throw new Error("initializeWasm() must be awaited first!");
1860 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
1861 return nativeResponseValue;
1864 export function LDKMessageSendEvent_SendOpenChannel_get_msg(ptr: number): number {
1865 if(!isWasmInitialized) {
1866 throw new Error("initializeWasm() must be awaited first!");
1868 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
1869 return nativeResponseValue;
1872 export function LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr: number): number {
1873 if(!isWasmInitialized) {
1874 throw new Error("initializeWasm() must be awaited first!");
1876 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
1877 return nativeResponseValue;
1880 export function LDKMessageSendEvent_SendFundingCreated_get_msg(ptr: number): number {
1881 if(!isWasmInitialized) {
1882 throw new Error("initializeWasm() must be awaited first!");
1884 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
1885 return nativeResponseValue;
1888 export function LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr: number): number {
1889 if(!isWasmInitialized) {
1890 throw new Error("initializeWasm() must be awaited first!");
1892 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
1893 return nativeResponseValue;
1896 export function LDKMessageSendEvent_SendFundingSigned_get_msg(ptr: number): number {
1897 if(!isWasmInitialized) {
1898 throw new Error("initializeWasm() must be awaited first!");
1900 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
1901 return nativeResponseValue;
1904 export function LDKMessageSendEvent_SendChannelReady_get_node_id(ptr: number): number {
1905 if(!isWasmInitialized) {
1906 throw new Error("initializeWasm() must be awaited first!");
1908 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
1909 return nativeResponseValue;
1912 export function LDKMessageSendEvent_SendChannelReady_get_msg(ptr: number): number {
1913 if(!isWasmInitialized) {
1914 throw new Error("initializeWasm() must be awaited first!");
1916 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
1917 return nativeResponseValue;
1920 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr: number): number {
1921 if(!isWasmInitialized) {
1922 throw new Error("initializeWasm() must be awaited first!");
1924 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
1925 return nativeResponseValue;
1928 export function LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr: number): number {
1929 if(!isWasmInitialized) {
1930 throw new Error("initializeWasm() must be awaited first!");
1932 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
1933 return nativeResponseValue;
1936 export function LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr: number): number {
1937 if(!isWasmInitialized) {
1938 throw new Error("initializeWasm() must be awaited first!");
1940 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
1941 return nativeResponseValue;
1944 export function LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr: number): number {
1945 if(!isWasmInitialized) {
1946 throw new Error("initializeWasm() must be awaited first!");
1948 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
1949 return nativeResponseValue;
1952 export function LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr: number): number {
1953 if(!isWasmInitialized) {
1954 throw new Error("initializeWasm() must be awaited first!");
1956 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
1957 return nativeResponseValue;
1960 export function LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr: number): number {
1961 if(!isWasmInitialized) {
1962 throw new Error("initializeWasm() must be awaited first!");
1964 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
1965 return nativeResponseValue;
1968 export function LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr: number): number {
1969 if(!isWasmInitialized) {
1970 throw new Error("initializeWasm() must be awaited first!");
1972 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
1973 return nativeResponseValue;
1976 export function LDKMessageSendEvent_SendClosingSigned_get_msg(ptr: number): number {
1977 if(!isWasmInitialized) {
1978 throw new Error("initializeWasm() must be awaited first!");
1980 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
1981 return nativeResponseValue;
1984 export function LDKMessageSendEvent_SendShutdown_get_node_id(ptr: number): number {
1985 if(!isWasmInitialized) {
1986 throw new Error("initializeWasm() must be awaited first!");
1988 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
1989 return nativeResponseValue;
1992 export function LDKMessageSendEvent_SendShutdown_get_msg(ptr: number): number {
1993 if(!isWasmInitialized) {
1994 throw new Error("initializeWasm() must be awaited first!");
1996 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShutdown_get_msg(ptr);
1997 return nativeResponseValue;
2000 export function LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr: number): number {
2001 if(!isWasmInitialized) {
2002 throw new Error("initializeWasm() must be awaited first!");
2004 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
2005 return nativeResponseValue;
2008 export function LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr: number): number {
2009 if(!isWasmInitialized) {
2010 throw new Error("initializeWasm() must be awaited first!");
2012 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
2013 return nativeResponseValue;
2016 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr: number): number {
2017 if(!isWasmInitialized) {
2018 throw new Error("initializeWasm() must be awaited first!");
2020 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
2021 return nativeResponseValue;
2024 export function LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr: number): number {
2025 if(!isWasmInitialized) {
2026 throw new Error("initializeWasm() must be awaited first!");
2028 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
2029 return nativeResponseValue;
2032 export function LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr: number): number {
2033 if(!isWasmInitialized) {
2034 throw new Error("initializeWasm() must be awaited first!");
2036 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
2037 return nativeResponseValue;
2040 export function LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr: number): number {
2041 if(!isWasmInitialized) {
2042 throw new Error("initializeWasm() must be awaited first!");
2044 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
2045 return nativeResponseValue;
2048 export function LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr: number): number {
2049 if(!isWasmInitialized) {
2050 throw new Error("initializeWasm() must be awaited first!");
2052 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
2053 return nativeResponseValue;
2056 export function LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr: number): number {
2057 if(!isWasmInitialized) {
2058 throw new Error("initializeWasm() must be awaited first!");
2060 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
2061 return nativeResponseValue;
2064 export function LDKMessageSendEvent_HandleError_get_node_id(ptr: number): number {
2065 if(!isWasmInitialized) {
2066 throw new Error("initializeWasm() must be awaited first!");
2068 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_node_id(ptr);
2069 return nativeResponseValue;
2072 export function LDKMessageSendEvent_HandleError_get_action(ptr: number): number {
2073 if(!isWasmInitialized) {
2074 throw new Error("initializeWasm() must be awaited first!");
2076 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_HandleError_get_action(ptr);
2077 return nativeResponseValue;
2080 export function LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr: number): number {
2081 if(!isWasmInitialized) {
2082 throw new Error("initializeWasm() must be awaited first!");
2084 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
2085 return nativeResponseValue;
2088 export function LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr: number): number {
2089 if(!isWasmInitialized) {
2090 throw new Error("initializeWasm() must be awaited first!");
2092 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
2093 return nativeResponseValue;
2096 export function LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr: number): number {
2097 if(!isWasmInitialized) {
2098 throw new Error("initializeWasm() must be awaited first!");
2100 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
2101 return nativeResponseValue;
2104 export function LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr: number): number {
2105 if(!isWasmInitialized) {
2106 throw new Error("initializeWasm() must be awaited first!");
2108 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
2109 return nativeResponseValue;
2112 export function LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr: number): number {
2113 if(!isWasmInitialized) {
2114 throw new Error("initializeWasm() must be awaited first!");
2116 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
2117 return nativeResponseValue;
2120 export function LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr: number): number {
2121 if(!isWasmInitialized) {
2122 throw new Error("initializeWasm() must be awaited first!");
2124 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
2125 return nativeResponseValue;
2128 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr: number): number {
2129 if(!isWasmInitialized) {
2130 throw new Error("initializeWasm() must be awaited first!");
2132 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
2133 return nativeResponseValue;
2136 export function LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr: number): number {
2137 if(!isWasmInitialized) {
2138 throw new Error("initializeWasm() must be awaited first!");
2140 const nativeResponseValue = wasm.TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
2141 return nativeResponseValue;
2143 // struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2145 export function CResult_TxOutAccessErrorZ_get_ok(owner: number): number {
2146 if(!isWasmInitialized) {
2147 throw new Error("initializeWasm() must be awaited first!");
2149 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_ok(owner);
2150 return nativeResponseValue;
2152 // enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner);
2154 export function CResult_TxOutAccessErrorZ_get_err(owner: number): AccessError {
2155 if(!isWasmInitialized) {
2156 throw new Error("initializeWasm() must be awaited first!");
2158 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_get_err(owner);
2159 return nativeResponseValue;
2161 // uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2163 export function C2Tuple_usizeTransactionZ_get_a(owner: number): number {
2164 if(!isWasmInitialized) {
2165 throw new Error("initializeWasm() must be awaited first!");
2167 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_a(owner);
2168 return nativeResponseValue;
2170 // struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner);
2172 export function C2Tuple_usizeTransactionZ_get_b(owner: number): number {
2173 if(!isWasmInitialized) {
2174 throw new Error("initializeWasm() must be awaited first!");
2176 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_get_b(owner);
2177 return nativeResponseValue;
2179 // void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2181 export function CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner: number): void {
2182 if(!isWasmInitialized) {
2183 throw new Error("initializeWasm() must be awaited first!");
2185 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner);
2186 // debug statements here
2188 // enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner);
2190 export function CResult_NoneChannelMonitorUpdateErrZ_get_err(owner: number): ChannelMonitorUpdateErr {
2191 if(!isWasmInitialized) {
2192 throw new Error("initializeWasm() must be awaited first!");
2194 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(owner);
2195 return nativeResponseValue;
2198 export class LDKMonitorEvent {
2199 protected constructor() {}
2202 export function LDKMonitorEvent_ty_from_ptr(ptr: number): number {
2203 if(!isWasmInitialized) {
2204 throw new Error("initializeWasm() must be awaited first!");
2206 const nativeResponseValue = wasm.TS_LDKMonitorEvent_ty_from_ptr(ptr);
2207 return nativeResponseValue;
2210 export function LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr: number): number {
2211 if(!isWasmInitialized) {
2212 throw new Error("initializeWasm() must be awaited first!");
2214 const nativeResponseValue = wasm.TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(ptr);
2215 return nativeResponseValue;
2218 export function LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr: number): number {
2219 if(!isWasmInitialized) {
2220 throw new Error("initializeWasm() must be awaited first!");
2222 const nativeResponseValue = wasm.TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(ptr);
2223 return nativeResponseValue;
2226 export function LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr: number): number {
2227 if(!isWasmInitialized) {
2228 throw new Error("initializeWasm() must be awaited first!");
2230 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(ptr);
2231 return nativeResponseValue;
2234 export function LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr: number): bigint {
2235 if(!isWasmInitialized) {
2236 throw new Error("initializeWasm() must be awaited first!");
2238 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(ptr);
2239 return nativeResponseValue;
2242 export function LDKMonitorEvent_UpdateFailed_get_update_failed(ptr: number): number {
2243 if(!isWasmInitialized) {
2244 throw new Error("initializeWasm() must be awaited first!");
2246 const nativeResponseValue = wasm.TS_LDKMonitorEvent_UpdateFailed_get_update_failed(ptr);
2247 return nativeResponseValue;
2249 // struct LDKOutPoint C2Tuple_OutPointCVec_MonitorEventZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR owner);
2251 export function C2Tuple_OutPointCVec_MonitorEventZZ_get_a(owner: number): number {
2252 if(!isWasmInitialized) {
2253 throw new Error("initializeWasm() must be awaited first!");
2255 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_get_a(owner);
2256 return nativeResponseValue;
2258 // struct LDKCVec_MonitorEventZ C2Tuple_OutPointCVec_MonitorEventZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR owner);
2260 export function C2Tuple_OutPointCVec_MonitorEventZZ_get_b(owner: number): number {
2261 if(!isWasmInitialized) {
2262 throw new Error("initializeWasm() must be awaited first!");
2264 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_get_b(owner);
2265 return nativeResponseValue;
2268 export class LDKCOption_C2Tuple_usizeTransactionZZ {
2269 protected constructor() {}
2272 export function LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr: number): number {
2273 if(!isWasmInitialized) {
2274 throw new Error("initializeWasm() must be awaited first!");
2276 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(ptr);
2277 return nativeResponseValue;
2280 export function LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr: number): number {
2281 if(!isWasmInitialized) {
2282 throw new Error("initializeWasm() must be awaited first!");
2284 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(ptr);
2285 return nativeResponseValue;
2287 // struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2289 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner: number): number {
2290 if(!isWasmInitialized) {
2291 throw new Error("initializeWasm() must be awaited first!");
2293 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner);
2294 return nativeResponseValue;
2296 // struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner);
2298 export function CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner: number): number {
2299 if(!isWasmInitialized) {
2300 throw new Error("initializeWasm() must be awaited first!");
2302 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner);
2303 return nativeResponseValue;
2305 // uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2307 export function C2Tuple_u64u64Z_get_a(owner: number): bigint {
2308 if(!isWasmInitialized) {
2309 throw new Error("initializeWasm() must be awaited first!");
2311 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_a(owner);
2312 return nativeResponseValue;
2314 // uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner);
2316 export function C2Tuple_u64u64Z_get_b(owner: number): bigint {
2317 if(!isWasmInitialized) {
2318 throw new Error("initializeWasm() must be awaited first!");
2320 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_get_b(owner);
2321 return nativeResponseValue;
2324 export class LDKCOption_C2Tuple_u64u64ZZ {
2325 protected constructor() {}
2328 export function LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr: number): number {
2329 if(!isWasmInitialized) {
2330 throw new Error("initializeWasm() must be awaited first!");
2332 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(ptr);
2333 return nativeResponseValue;
2336 export function LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr: number): number {
2337 if(!isWasmInitialized) {
2338 throw new Error("initializeWasm() must be awaited first!");
2340 const nativeResponseValue = wasm.TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(ptr);
2341 return nativeResponseValue;
2344 export interface LDKLogger {
2345 log (record: number): void;
2349 export function LDKLogger_new(impl: LDKLogger): number {
2350 if(!isWasmInitialized) {
2351 throw new Error("initializeWasm() must be awaited first!");
2353 var new_obj_idx = js_objs.length;
2354 for (var i = 0; i < js_objs.length; i++) {
2355 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2357 js_objs[i] = new WeakRef(impl);
2358 return wasm.TS_LDKLogger_new(i);
2360 // struct LDKProbabilisticScorer *CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2362 export function CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner: number): number {
2363 if(!isWasmInitialized) {
2364 throw new Error("initializeWasm() must be awaited first!");
2366 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner);
2367 return nativeResponseValue;
2369 // struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner);
2371 export function CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner: number): number {
2372 if(!isWasmInitialized) {
2373 throw new Error("initializeWasm() must be awaited first!");
2375 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner);
2376 return nativeResponseValue;
2378 // struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2380 export function CResult_InitFeaturesDecodeErrorZ_get_ok(owner: number): number {
2381 if(!isWasmInitialized) {
2382 throw new Error("initializeWasm() must be awaited first!");
2384 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_ok(owner);
2385 return nativeResponseValue;
2387 // struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner);
2389 export function CResult_InitFeaturesDecodeErrorZ_get_err(owner: number): number {
2390 if(!isWasmInitialized) {
2391 throw new Error("initializeWasm() must be awaited first!");
2393 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_get_err(owner);
2394 return nativeResponseValue;
2396 // struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2398 export function CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner: number): number {
2399 if(!isWasmInitialized) {
2400 throw new Error("initializeWasm() must be awaited first!");
2402 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner);
2403 return nativeResponseValue;
2405 // struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner);
2407 export function CResult_ChannelFeaturesDecodeErrorZ_get_err(owner: number): number {
2408 if(!isWasmInitialized) {
2409 throw new Error("initializeWasm() must be awaited first!");
2411 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(owner);
2412 return nativeResponseValue;
2414 // struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2416 export function CResult_NodeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2417 if(!isWasmInitialized) {
2418 throw new Error("initializeWasm() must be awaited first!");
2420 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(owner);
2421 return nativeResponseValue;
2423 // struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2425 export function CResult_NodeFeaturesDecodeErrorZ_get_err(owner: number): number {
2426 if(!isWasmInitialized) {
2427 throw new Error("initializeWasm() must be awaited first!");
2429 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_get_err(owner);
2430 return nativeResponseValue;
2432 // struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2434 export function CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner: number): number {
2435 if(!isWasmInitialized) {
2436 throw new Error("initializeWasm() must be awaited first!");
2438 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner);
2439 return nativeResponseValue;
2441 // struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner);
2443 export function CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner: number): number {
2444 if(!isWasmInitialized) {
2445 throw new Error("initializeWasm() must be awaited first!");
2447 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner);
2448 return nativeResponseValue;
2450 // struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2452 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner: number): number {
2453 if(!isWasmInitialized) {
2454 throw new Error("initializeWasm() must be awaited first!");
2456 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner);
2457 return nativeResponseValue;
2459 // struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner);
2461 export function CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner: number): number {
2462 if(!isWasmInitialized) {
2463 throw new Error("initializeWasm() must be awaited first!");
2465 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner);
2466 return nativeResponseValue;
2468 // struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2470 export function CResult_NodeIdDecodeErrorZ_get_ok(owner: number): number {
2471 if(!isWasmInitialized) {
2472 throw new Error("initializeWasm() must be awaited first!");
2474 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_ok(owner);
2475 return nativeResponseValue;
2477 // struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner);
2479 export function CResult_NodeIdDecodeErrorZ_get_err(owner: number): number {
2480 if(!isWasmInitialized) {
2481 throw new Error("initializeWasm() must be awaited first!");
2483 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_get_err(owner);
2484 return nativeResponseValue;
2486 // struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2488 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner: number): number {
2489 if(!isWasmInitialized) {
2490 throw new Error("initializeWasm() must be awaited first!");
2492 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner);
2493 return nativeResponseValue;
2495 // struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner);
2497 export function CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner: number): number {
2498 if(!isWasmInitialized) {
2499 throw new Error("initializeWasm() must be awaited first!");
2501 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner);
2502 return nativeResponseValue;
2505 export interface LDKAccess {
2506 get_utxo (genesis_hash: number, short_channel_id: bigint): number;
2510 export function LDKAccess_new(impl: LDKAccess): number {
2511 if(!isWasmInitialized) {
2512 throw new Error("initializeWasm() must be awaited first!");
2514 var new_obj_idx = js_objs.length;
2515 for (var i = 0; i < js_objs.length; i++) {
2516 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
2518 js_objs[i] = new WeakRef(impl);
2519 return wasm.TS_LDKAccess_new(i);
2521 // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
2523 export function Access_get_utxo(this_arg: number, genesis_hash: number, short_channel_id: bigint): number {
2524 if(!isWasmInitialized) {
2525 throw new Error("initializeWasm() must be awaited first!");
2527 const nativeResponseValue = wasm.TS_Access_get_utxo(this_arg, genesis_hash, short_channel_id);
2528 return nativeResponseValue;
2531 export class LDKCOption_AccessZ {
2532 protected constructor() {}
2535 export function LDKCOption_AccessZ_ty_from_ptr(ptr: number): number {
2536 if(!isWasmInitialized) {
2537 throw new Error("initializeWasm() must be awaited first!");
2539 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_ty_from_ptr(ptr);
2540 return nativeResponseValue;
2543 export function LDKCOption_AccessZ_Some_get_some(ptr: number): number {
2544 if(!isWasmInitialized) {
2545 throw new Error("initializeWasm() must be awaited first!");
2547 const nativeResponseValue = wasm.TS_LDKCOption_AccessZ_Some_get_some(ptr);
2548 return nativeResponseValue;
2550 // bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2552 export function CResult_boolLightningErrorZ_get_ok(owner: number): boolean {
2553 if(!isWasmInitialized) {
2554 throw new Error("initializeWasm() must be awaited first!");
2556 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_ok(owner);
2557 return nativeResponseValue;
2559 // struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner);
2561 export function CResult_boolLightningErrorZ_get_err(owner: number): number {
2562 if(!isWasmInitialized) {
2563 throw new Error("initializeWasm() must be awaited first!");
2565 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_get_err(owner);
2566 return nativeResponseValue;
2568 // struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2570 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner: number): number {
2571 if(!isWasmInitialized) {
2572 throw new Error("initializeWasm() must be awaited first!");
2574 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner);
2575 return nativeResponseValue;
2577 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2579 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner: number): number {
2580 if(!isWasmInitialized) {
2581 throw new Error("initializeWasm() must be awaited first!");
2583 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner);
2584 return nativeResponseValue;
2586 // struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner);
2588 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner: number): number {
2589 if(!isWasmInitialized) {
2590 throw new Error("initializeWasm() must be awaited first!");
2592 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner);
2593 return nativeResponseValue;
2595 // void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2597 export function CResult_NoneLightningErrorZ_get_ok(owner: number): void {
2598 if(!isWasmInitialized) {
2599 throw new Error("initializeWasm() must be awaited first!");
2601 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_ok(owner);
2602 // debug statements here
2604 // struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner);
2606 export function CResult_NoneLightningErrorZ_get_err(owner: number): number {
2607 if(!isWasmInitialized) {
2608 throw new Error("initializeWasm() must be awaited first!");
2610 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_get_err(owner);
2611 return nativeResponseValue;
2613 // struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2615 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner: number): number {
2616 if(!isWasmInitialized) {
2617 throw new Error("initializeWasm() must be awaited first!");
2619 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner);
2620 return nativeResponseValue;
2622 // struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner);
2624 export function CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner: number): number {
2625 if(!isWasmInitialized) {
2626 throw new Error("initializeWasm() must be awaited first!");
2628 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner);
2629 return nativeResponseValue;
2631 // struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2633 export function CResult_ChannelInfoDecodeErrorZ_get_ok(owner: number): number {
2634 if(!isWasmInitialized) {
2635 throw new Error("initializeWasm() must be awaited first!");
2637 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_ok(owner);
2638 return nativeResponseValue;
2640 // struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner);
2642 export function CResult_ChannelInfoDecodeErrorZ_get_err(owner: number): number {
2643 if(!isWasmInitialized) {
2644 throw new Error("initializeWasm() must be awaited first!");
2646 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_get_err(owner);
2647 return nativeResponseValue;
2649 // struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2651 export function CResult_RoutingFeesDecodeErrorZ_get_ok(owner: number): number {
2652 if(!isWasmInitialized) {
2653 throw new Error("initializeWasm() must be awaited first!");
2655 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_ok(owner);
2656 return nativeResponseValue;
2658 // struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner);
2660 export function CResult_RoutingFeesDecodeErrorZ_get_err(owner: number): number {
2661 if(!isWasmInitialized) {
2662 throw new Error("initializeWasm() must be awaited first!");
2664 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_get_err(owner);
2665 return nativeResponseValue;
2668 export class LDKNetAddress {
2669 protected constructor() {}
2672 export function LDKNetAddress_ty_from_ptr(ptr: number): number {
2673 if(!isWasmInitialized) {
2674 throw new Error("initializeWasm() must be awaited first!");
2676 const nativeResponseValue = wasm.TS_LDKNetAddress_ty_from_ptr(ptr);
2677 return nativeResponseValue;
2680 export function LDKNetAddress_IPv4_get_addr(ptr: number): number {
2681 if(!isWasmInitialized) {
2682 throw new Error("initializeWasm() must be awaited first!");
2684 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_addr(ptr);
2685 return nativeResponseValue;
2688 export function LDKNetAddress_IPv4_get_port(ptr: number): number {
2689 if(!isWasmInitialized) {
2690 throw new Error("initializeWasm() must be awaited first!");
2692 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv4_get_port(ptr);
2693 return nativeResponseValue;
2696 export function LDKNetAddress_IPv6_get_addr(ptr: number): number {
2697 if(!isWasmInitialized) {
2698 throw new Error("initializeWasm() must be awaited first!");
2700 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_addr(ptr);
2701 return nativeResponseValue;
2704 export function LDKNetAddress_IPv6_get_port(ptr: number): number {
2705 if(!isWasmInitialized) {
2706 throw new Error("initializeWasm() must be awaited first!");
2708 const nativeResponseValue = wasm.TS_LDKNetAddress_IPv6_get_port(ptr);
2709 return nativeResponseValue;
2712 export function LDKNetAddress_OnionV2_get_onion_v2(ptr: number): number {
2713 if(!isWasmInitialized) {
2714 throw new Error("initializeWasm() must be awaited first!");
2716 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV2_get_onion_v2(ptr);
2717 return nativeResponseValue;
2720 export function LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr: number): number {
2721 if(!isWasmInitialized) {
2722 throw new Error("initializeWasm() must be awaited first!");
2724 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(ptr);
2725 return nativeResponseValue;
2728 export function LDKNetAddress_OnionV3_get_checksum(ptr: number): number {
2729 if(!isWasmInitialized) {
2730 throw new Error("initializeWasm() must be awaited first!");
2732 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_checksum(ptr);
2733 return nativeResponseValue;
2736 export function LDKNetAddress_OnionV3_get_version(ptr: number): number {
2737 if(!isWasmInitialized) {
2738 throw new Error("initializeWasm() must be awaited first!");
2740 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_version(ptr);
2741 return nativeResponseValue;
2744 export function LDKNetAddress_OnionV3_get_port(ptr: number): number {
2745 if(!isWasmInitialized) {
2746 throw new Error("initializeWasm() must be awaited first!");
2748 const nativeResponseValue = wasm.TS_LDKNetAddress_OnionV3_get_port(ptr);
2749 return nativeResponseValue;
2751 // struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2753 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner: number): number {
2754 if(!isWasmInitialized) {
2755 throw new Error("initializeWasm() must be awaited first!");
2757 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner);
2758 return nativeResponseValue;
2760 // struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner);
2762 export function CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner: number): number {
2763 if(!isWasmInitialized) {
2764 throw new Error("initializeWasm() must be awaited first!");
2766 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner);
2767 return nativeResponseValue;
2769 // struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
2771 export function CResult_NodeAliasDecodeErrorZ_get_ok(owner: number): number {
2772 if(!isWasmInitialized) {
2773 throw new Error("initializeWasm() must be awaited first!");
2775 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_ok(owner);
2776 return nativeResponseValue;
2778 // struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner);
2780 export function CResult_NodeAliasDecodeErrorZ_get_err(owner: number): number {
2781 if(!isWasmInitialized) {
2782 throw new Error("initializeWasm() must be awaited first!");
2784 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_get_err(owner);
2785 return nativeResponseValue;
2787 // struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2789 export function CResult_NodeInfoDecodeErrorZ_get_ok(owner: number): number {
2790 if(!isWasmInitialized) {
2791 throw new Error("initializeWasm() must be awaited first!");
2793 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_ok(owner);
2794 return nativeResponseValue;
2796 // struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner);
2798 export function CResult_NodeInfoDecodeErrorZ_get_err(owner: number): number {
2799 if(!isWasmInitialized) {
2800 throw new Error("initializeWasm() must be awaited first!");
2802 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_get_err(owner);
2803 return nativeResponseValue;
2805 // struct LDKNetworkGraph *CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
2807 export function CResult_NetworkGraphDecodeErrorZ_get_ok(owner: number): number {
2808 if(!isWasmInitialized) {
2809 throw new Error("initializeWasm() must be awaited first!");
2811 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_ok(owner);
2812 return nativeResponseValue;
2814 // struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner);
2816 export function CResult_NetworkGraphDecodeErrorZ_get_err(owner: number): number {
2817 if(!isWasmInitialized) {
2818 throw new Error("initializeWasm() must be awaited first!");
2820 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_get_err(owner);
2821 return nativeResponseValue;
2824 export class LDKCOption_CVec_NetAddressZZ {
2825 protected constructor() {}
2828 export function LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr: number): number {
2829 if(!isWasmInitialized) {
2830 throw new Error("initializeWasm() must be awaited first!");
2832 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(ptr);
2833 return nativeResponseValue;
2836 export function LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr: number): number {
2837 if(!isWasmInitialized) {
2838 throw new Error("initializeWasm() must be awaited first!");
2840 const nativeResponseValue = wasm.TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(ptr);
2841 return nativeResponseValue;
2843 // struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2845 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2846 if(!isWasmInitialized) {
2847 throw new Error("initializeWasm() must be awaited first!");
2849 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2850 return nativeResponseValue;
2852 // struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2854 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2855 if(!isWasmInitialized) {
2856 throw new Error("initializeWasm() must be awaited first!");
2858 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2859 return nativeResponseValue;
2861 // struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2863 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2864 if(!isWasmInitialized) {
2865 throw new Error("initializeWasm() must be awaited first!");
2867 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner);
2868 return nativeResponseValue;
2870 // struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2872 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2873 if(!isWasmInitialized) {
2874 throw new Error("initializeWasm() must be awaited first!");
2876 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner);
2877 return nativeResponseValue;
2879 // struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2881 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner: number): number {
2882 if(!isWasmInitialized) {
2883 throw new Error("initializeWasm() must be awaited first!");
2885 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner);
2886 return nativeResponseValue;
2888 // struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner);
2890 export function CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner: number): number {
2891 if(!isWasmInitialized) {
2892 throw new Error("initializeWasm() must be awaited first!");
2894 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner);
2895 return nativeResponseValue;
2897 // struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2899 export function C2Tuple_SignatureCVec_SignatureZZ_get_a(owner: number): number {
2900 if(!isWasmInitialized) {
2901 throw new Error("initializeWasm() must be awaited first!");
2903 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(owner);
2904 return nativeResponseValue;
2906 // struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner);
2908 export function C2Tuple_SignatureCVec_SignatureZZ_get_b(owner: number): number {
2909 if(!isWasmInitialized) {
2910 throw new Error("initializeWasm() must be awaited first!");
2912 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(owner);
2913 return nativeResponseValue;
2915 // struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2917 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner: number): number {
2918 if(!isWasmInitialized) {
2919 throw new Error("initializeWasm() must be awaited first!");
2921 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner);
2922 return nativeResponseValue;
2924 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner);
2926 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner: number): void {
2927 if(!isWasmInitialized) {
2928 throw new Error("initializeWasm() must be awaited first!");
2930 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner);
2931 // debug statements here
2933 // struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2935 export function CResult_SignatureNoneZ_get_ok(owner: number): number {
2936 if(!isWasmInitialized) {
2937 throw new Error("initializeWasm() must be awaited first!");
2939 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_ok(owner);
2940 return nativeResponseValue;
2942 // void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner);
2944 export function CResult_SignatureNoneZ_get_err(owner: number): void {
2945 if(!isWasmInitialized) {
2946 throw new Error("initializeWasm() must be awaited first!");
2948 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_get_err(owner);
2949 // debug statements here
2951 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2953 export function C2Tuple_SignatureSignatureZ_get_a(owner: number): number {
2954 if(!isWasmInitialized) {
2955 throw new Error("initializeWasm() must be awaited first!");
2957 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_a(owner);
2958 return nativeResponseValue;
2960 // struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner);
2962 export function C2Tuple_SignatureSignatureZ_get_b(owner: number): number {
2963 if(!isWasmInitialized) {
2964 throw new Error("initializeWasm() must be awaited first!");
2966 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_get_b(owner);
2967 return nativeResponseValue;
2969 // struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
2971 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner: number): number {
2972 if(!isWasmInitialized) {
2973 throw new Error("initializeWasm() must be awaited first!");
2975 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner);
2976 return nativeResponseValue;
2978 // void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner);
2980 export function CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner: number): void {
2981 if(!isWasmInitialized) {
2982 throw new Error("initializeWasm() must be awaited first!");
2984 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner);
2985 // debug statements here
2987 // struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
2989 export function CResult_SecretKeyNoneZ_get_ok(owner: number): number {
2990 if(!isWasmInitialized) {
2991 throw new Error("initializeWasm() must be awaited first!");
2993 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_ok(owner);
2994 return nativeResponseValue;
2996 // void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner);
2998 export function CResult_SecretKeyNoneZ_get_err(owner: number): void {
2999 if(!isWasmInitialized) {
3000 throw new Error("initializeWasm() must be awaited first!");
3002 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_get_err(owner);
3003 // debug statements here
3006 export interface LDKBaseSign {
3007 get_per_commitment_point (idx: bigint): number;
3008 release_commitment_secret (idx: bigint): number;
3009 validate_holder_commitment (holder_tx: number, preimages: number): number;
3010 channel_keys_id (): number;
3011 sign_counterparty_commitment (commitment_tx: number, preimages: number): number;
3012 validate_counterparty_revocation (idx: bigint, secret: number): number;
3013 sign_holder_commitment_and_htlcs (commitment_tx: number): number;
3014 sign_justice_revoked_output (justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number;
3015 sign_justice_revoked_htlc (justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number;
3016 sign_counterparty_htlc_transaction (htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number;
3017 sign_closing_transaction (closing_tx: number): number;
3018 sign_channel_announcement (msg: number): number;
3019 ready_channel (channel_parameters: number): void;
3023 export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: number): number {
3024 if(!isWasmInitialized) {
3025 throw new Error("initializeWasm() must be awaited first!");
3027 var new_obj_idx = js_objs.length;
3028 for (var i = 0; i < js_objs.length; i++) {
3029 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3031 js_objs[i] = new WeakRef(impl);
3032 return wasm.TS_LDKBaseSign_new(i);
3034 // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3036 export function BaseSign_get_per_commitment_point(this_arg: number, idx: bigint): number {
3037 if(!isWasmInitialized) {
3038 throw new Error("initializeWasm() must be awaited first!");
3040 const nativeResponseValue = wasm.TS_BaseSign_get_per_commitment_point(this_arg, idx);
3041 return nativeResponseValue;
3043 // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
3045 export function BaseSign_release_commitment_secret(this_arg: number, idx: bigint): number {
3046 if(!isWasmInitialized) {
3047 throw new Error("initializeWasm() must be awaited first!");
3049 const nativeResponseValue = wasm.TS_BaseSign_release_commitment_secret(this_arg, idx);
3050 return nativeResponseValue;
3052 // LDKCResult_NoneNoneZ BaseSign_validate_holder_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR holder_tx, struct LDKCVec_PaymentPreimageZ preimages
3054 export function BaseSign_validate_holder_commitment(this_arg: number, holder_tx: number, preimages: number): number {
3055 if(!isWasmInitialized) {
3056 throw new Error("initializeWasm() must be awaited first!");
3058 const nativeResponseValue = wasm.TS_BaseSign_validate_holder_commitment(this_arg, holder_tx, preimages);
3059 return nativeResponseValue;
3061 // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
3063 export function BaseSign_channel_keys_id(this_arg: number): number {
3064 if(!isWasmInitialized) {
3065 throw new Error("initializeWasm() must be awaited first!");
3067 const nativeResponseValue = wasm.TS_BaseSign_channel_keys_id(this_arg);
3068 return nativeResponseValue;
3070 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx, struct LDKCVec_PaymentPreimageZ preimages
3072 export function BaseSign_sign_counterparty_commitment(this_arg: number, commitment_tx: number, preimages: number): number {
3073 if(!isWasmInitialized) {
3074 throw new Error("initializeWasm() must be awaited first!");
3076 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_commitment(this_arg, commitment_tx, preimages);
3077 return nativeResponseValue;
3079 // LDKCResult_NoneNoneZ BaseSign_validate_counterparty_revocation LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx, const uint8_t (*secret)[32]
3081 export function BaseSign_validate_counterparty_revocation(this_arg: number, idx: bigint, secret: number): number {
3082 if(!isWasmInitialized) {
3083 throw new Error("initializeWasm() must be awaited first!");
3085 const nativeResponseValue = wasm.TS_BaseSign_validate_counterparty_revocation(this_arg, idx, secret);
3086 return nativeResponseValue;
3088 // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
3090 export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
3091 if(!isWasmInitialized) {
3092 throw new Error("initializeWasm() must be awaited first!");
3094 const nativeResponseValue = wasm.TS_BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
3095 return nativeResponseValue;
3097 // 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]
3099 export function BaseSign_sign_justice_revoked_output(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number): number {
3100 if(!isWasmInitialized) {
3101 throw new Error("initializeWasm() must be awaited first!");
3103 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_output(this_arg, justice_tx, input, amount, per_commitment_key);
3104 return nativeResponseValue;
3106 // 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
3108 export function BaseSign_sign_justice_revoked_htlc(this_arg: number, justice_tx: number, input: number, amount: bigint, per_commitment_key: number, htlc: number): number {
3109 if(!isWasmInitialized) {
3110 throw new Error("initializeWasm() must be awaited first!");
3112 const nativeResponseValue = wasm.TS_BaseSign_sign_justice_revoked_htlc(this_arg, justice_tx, input, amount, per_commitment_key, htlc);
3113 return nativeResponseValue;
3115 // 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
3117 export function BaseSign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: number, input: number, amount: bigint, per_commitment_point: number, htlc: number): number {
3118 if(!isWasmInitialized) {
3119 throw new Error("initializeWasm() must be awaited first!");
3121 const nativeResponseValue = wasm.TS_BaseSign_sign_counterparty_htlc_transaction(this_arg, htlc_tx, input, amount, per_commitment_point, htlc);
3122 return nativeResponseValue;
3124 // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, const struct LDKClosingTransaction *NONNULL_PTR closing_tx
3126 export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: number): number {
3127 if(!isWasmInitialized) {
3128 throw new Error("initializeWasm() must be awaited first!");
3130 const nativeResponseValue = wasm.TS_BaseSign_sign_closing_transaction(this_arg, closing_tx);
3131 return nativeResponseValue;
3133 // LDKCResult_C2Tuple_SignatureSignatureZNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
3135 export function BaseSign_sign_channel_announcement(this_arg: number, msg: number): number {
3136 if(!isWasmInitialized) {
3137 throw new Error("initializeWasm() must be awaited first!");
3139 const nativeResponseValue = wasm.TS_BaseSign_sign_channel_announcement(this_arg, msg);
3140 return nativeResponseValue;
3142 // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
3144 export function BaseSign_ready_channel(this_arg: number, channel_parameters: number): void {
3145 if(!isWasmInitialized) {
3146 throw new Error("initializeWasm() must be awaited first!");
3148 const nativeResponseValue = wasm.TS_BaseSign_ready_channel(this_arg, channel_parameters);
3149 // debug statements here
3151 // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
3153 export function BaseSign_get_pubkeys(this_arg: number): number {
3154 if(!isWasmInitialized) {
3155 throw new Error("initializeWasm() must be awaited first!");
3157 const nativeResponseValue = wasm.TS_BaseSign_get_pubkeys(this_arg);
3158 return nativeResponseValue;
3161 export interface LDKSign {
3166 export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: number): number {
3167 if(!isWasmInitialized) {
3168 throw new Error("initializeWasm() must be awaited first!");
3170 var new_obj_idx = js_objs.length;
3171 for (var i = 0; i < js_objs.length; i++) {
3172 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3174 js_objs[i] = new WeakRef(impl);
3175 return wasm.TS_LDKSign_new(i);
3177 // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
3179 export function Sign_write(this_arg: number): number {
3180 if(!isWasmInitialized) {
3181 throw new Error("initializeWasm() must be awaited first!");
3183 const nativeResponseValue = wasm.TS_Sign_write(this_arg);
3184 return nativeResponseValue;
3186 // struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3188 export function CResult_SignDecodeErrorZ_get_ok(owner: number): number {
3189 if(!isWasmInitialized) {
3190 throw new Error("initializeWasm() must be awaited first!");
3192 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_ok(owner);
3193 return nativeResponseValue;
3195 // struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner);
3197 export function CResult_SignDecodeErrorZ_get_err(owner: number): number {
3198 if(!isWasmInitialized) {
3199 throw new Error("initializeWasm() must be awaited first!");
3201 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_get_err(owner);
3202 return nativeResponseValue;
3204 // struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3206 export function CResult_RecoverableSignatureNoneZ_get_ok(owner: number): number {
3207 if(!isWasmInitialized) {
3208 throw new Error("initializeWasm() must be awaited first!");
3210 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_ok(owner);
3211 return nativeResponseValue;
3213 // void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner);
3215 export function CResult_RecoverableSignatureNoneZ_get_err(owner: number): void {
3216 if(!isWasmInitialized) {
3217 throw new Error("initializeWasm() must be awaited first!");
3219 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_get_err(owner);
3220 // debug statements here
3222 // struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3224 export function CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner: number): number {
3225 if(!isWasmInitialized) {
3226 throw new Error("initializeWasm() must be awaited first!");
3228 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner);
3229 return nativeResponseValue;
3231 // void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner);
3233 export function CResult_CVec_CVec_u8ZZNoneZ_get_err(owner: number): void {
3234 if(!isWasmInitialized) {
3235 throw new Error("initializeWasm() must be awaited first!");
3237 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(owner);
3238 // debug statements here
3240 // struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3242 export function CResult_InMemorySignerDecodeErrorZ_get_ok(owner: number): number {
3243 if(!isWasmInitialized) {
3244 throw new Error("initializeWasm() must be awaited first!");
3246 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_ok(owner);
3247 return nativeResponseValue;
3249 // struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner);
3251 export function CResult_InMemorySignerDecodeErrorZ_get_err(owner: number): number {
3252 if(!isWasmInitialized) {
3253 throw new Error("initializeWasm() must be awaited first!");
3255 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_get_err(owner);
3256 return nativeResponseValue;
3258 // struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3260 export function CResult_TransactionNoneZ_get_ok(owner: number): number {
3261 if(!isWasmInitialized) {
3262 throw new Error("initializeWasm() must be awaited first!");
3264 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_ok(owner);
3265 return nativeResponseValue;
3267 // void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner);
3269 export function CResult_TransactionNoneZ_get_err(owner: number): void {
3270 if(!isWasmInitialized) {
3271 throw new Error("initializeWasm() must be awaited first!");
3273 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_get_err(owner);
3274 // debug statements here
3277 export class LDKCOption_u16Z {
3278 protected constructor() {}
3281 export function LDKCOption_u16Z_ty_from_ptr(ptr: number): number {
3282 if(!isWasmInitialized) {
3283 throw new Error("initializeWasm() must be awaited first!");
3285 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_ty_from_ptr(ptr);
3286 return nativeResponseValue;
3289 export function LDKCOption_u16Z_Some_get_some(ptr: number): number {
3290 if(!isWasmInitialized) {
3291 throw new Error("initializeWasm() must be awaited first!");
3293 const nativeResponseValue = wasm.TS_LDKCOption_u16Z_Some_get_some(ptr);
3294 return nativeResponseValue;
3297 export class LDKAPIError {
3298 protected constructor() {}
3301 export function LDKAPIError_ty_from_ptr(ptr: number): number {
3302 if(!isWasmInitialized) {
3303 throw new Error("initializeWasm() must be awaited first!");
3305 const nativeResponseValue = wasm.TS_LDKAPIError_ty_from_ptr(ptr);
3306 return nativeResponseValue;
3309 export function LDKAPIError_APIMisuseError_get_err(ptr: number): number {
3310 if(!isWasmInitialized) {
3311 throw new Error("initializeWasm() must be awaited first!");
3313 const nativeResponseValue = wasm.TS_LDKAPIError_APIMisuseError_get_err(ptr);
3314 return nativeResponseValue;
3317 export function LDKAPIError_FeeRateTooHigh_get_err(ptr: number): number {
3318 if(!isWasmInitialized) {
3319 throw new Error("initializeWasm() must be awaited first!");
3321 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_err(ptr);
3322 return nativeResponseValue;
3325 export function LDKAPIError_FeeRateTooHigh_get_feerate(ptr: number): number {
3326 if(!isWasmInitialized) {
3327 throw new Error("initializeWasm() must be awaited first!");
3329 const nativeResponseValue = wasm.TS_LDKAPIError_FeeRateTooHigh_get_feerate(ptr);
3330 return nativeResponseValue;
3333 export function LDKAPIError_RouteError_get_err(ptr: number): number {
3334 if(!isWasmInitialized) {
3335 throw new Error("initializeWasm() must be awaited first!");
3337 const nativeResponseValue = wasm.TS_LDKAPIError_RouteError_get_err(ptr);
3338 return nativeResponseValue;
3341 export function LDKAPIError_ChannelUnavailable_get_err(ptr: number): number {
3342 if(!isWasmInitialized) {
3343 throw new Error("initializeWasm() must be awaited first!");
3345 const nativeResponseValue = wasm.TS_LDKAPIError_ChannelUnavailable_get_err(ptr);
3346 return nativeResponseValue;
3349 export function LDKAPIError_IncompatibleShutdownScript_get_script(ptr: number): number {
3350 if(!isWasmInitialized) {
3351 throw new Error("initializeWasm() must be awaited first!");
3353 const nativeResponseValue = wasm.TS_LDKAPIError_IncompatibleShutdownScript_get_script(ptr);
3354 return nativeResponseValue;
3356 // void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3358 export function CResult_NoneAPIErrorZ_get_ok(owner: number): void {
3359 if(!isWasmInitialized) {
3360 throw new Error("initializeWasm() must be awaited first!");
3362 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_ok(owner);
3363 // debug statements here
3365 // struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner);
3367 export function CResult_NoneAPIErrorZ_get_err(owner: number): number {
3368 if(!isWasmInitialized) {
3369 throw new Error("initializeWasm() must be awaited first!");
3371 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_get_err(owner);
3372 return nativeResponseValue;
3374 // struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3376 export function CResult__u832APIErrorZ_get_ok(owner: number): number {
3377 if(!isWasmInitialized) {
3378 throw new Error("initializeWasm() must be awaited first!");
3380 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_ok(owner);
3381 return nativeResponseValue;
3383 // struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner);
3385 export function CResult__u832APIErrorZ_get_err(owner: number): number {
3386 if(!isWasmInitialized) {
3387 throw new Error("initializeWasm() must be awaited first!");
3389 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_get_err(owner);
3390 return nativeResponseValue;
3393 export class LDKPaymentSendFailure {
3394 protected constructor() {}
3397 export function LDKPaymentSendFailure_ty_from_ptr(ptr: number): number {
3398 if(!isWasmInitialized) {
3399 throw new Error("initializeWasm() must be awaited first!");
3401 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ty_from_ptr(ptr);
3402 return nativeResponseValue;
3405 export function LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr: number): number {
3406 if(!isWasmInitialized) {
3407 throw new Error("initializeWasm() must be awaited first!");
3409 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(ptr);
3410 return nativeResponseValue;
3413 export function LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr: number): number {
3414 if(!isWasmInitialized) {
3415 throw new Error("initializeWasm() must be awaited first!");
3417 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(ptr);
3418 return nativeResponseValue;
3421 export function LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr: number): number {
3422 if(!isWasmInitialized) {
3423 throw new Error("initializeWasm() must be awaited first!");
3425 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(ptr);
3426 return nativeResponseValue;
3429 export function LDKPaymentSendFailure_PartialFailure_get_results(ptr: number): number {
3430 if(!isWasmInitialized) {
3431 throw new Error("initializeWasm() must be awaited first!");
3433 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_results(ptr);
3434 return nativeResponseValue;
3437 export function LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr: number): number {
3438 if(!isWasmInitialized) {
3439 throw new Error("initializeWasm() must be awaited first!");
3441 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(ptr);
3442 return nativeResponseValue;
3445 export function LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr: number): number {
3446 if(!isWasmInitialized) {
3447 throw new Error("initializeWasm() must be awaited first!");
3449 const nativeResponseValue = wasm.TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(ptr);
3450 return nativeResponseValue;
3452 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3454 export function CResult_PaymentIdPaymentSendFailureZ_get_ok(owner: number): number {
3455 if(!isWasmInitialized) {
3456 throw new Error("initializeWasm() must be awaited first!");
3458 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(owner);
3459 return nativeResponseValue;
3461 // struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner);
3463 export function CResult_PaymentIdPaymentSendFailureZ_get_err(owner: number): number {
3464 if(!isWasmInitialized) {
3465 throw new Error("initializeWasm() must be awaited first!");
3467 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_get_err(owner);
3468 return nativeResponseValue;
3470 // void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3472 export function CResult_NonePaymentSendFailureZ_get_ok(owner: number): void {
3473 if(!isWasmInitialized) {
3474 throw new Error("initializeWasm() must be awaited first!");
3476 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_ok(owner);
3477 // debug statements here
3479 // struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner);
3481 export function CResult_NonePaymentSendFailureZ_get_err(owner: number): number {
3482 if(!isWasmInitialized) {
3483 throw new Error("initializeWasm() must be awaited first!");
3485 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_get_err(owner);
3486 return nativeResponseValue;
3488 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3490 export function C2Tuple_PaymentHashPaymentIdZ_get_a(owner: number): number {
3491 if(!isWasmInitialized) {
3492 throw new Error("initializeWasm() must be awaited first!");
3494 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_a(owner);
3495 return nativeResponseValue;
3497 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner);
3499 export function C2Tuple_PaymentHashPaymentIdZ_get_b(owner: number): number {
3500 if(!isWasmInitialized) {
3501 throw new Error("initializeWasm() must be awaited first!");
3503 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_get_b(owner);
3504 return nativeResponseValue;
3506 // struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3508 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner: number): number {
3509 if(!isWasmInitialized) {
3510 throw new Error("initializeWasm() must be awaited first!");
3512 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner);
3513 return nativeResponseValue;
3515 // struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner);
3517 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner: number): number {
3518 if(!isWasmInitialized) {
3519 throw new Error("initializeWasm() must be awaited first!");
3521 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner);
3522 return nativeResponseValue;
3524 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3526 export function C2Tuple_PaymentHashPaymentSecretZ_get_a(owner: number): number {
3527 if(!isWasmInitialized) {
3528 throw new Error("initializeWasm() must be awaited first!");
3530 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(owner);
3531 return nativeResponseValue;
3533 // struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner);
3535 export function C2Tuple_PaymentHashPaymentSecretZ_get_b(owner: number): number {
3536 if(!isWasmInitialized) {
3537 throw new Error("initializeWasm() must be awaited first!");
3539 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(owner);
3540 return nativeResponseValue;
3542 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3544 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner: number): number {
3545 if(!isWasmInitialized) {
3546 throw new Error("initializeWasm() must be awaited first!");
3548 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner);
3549 return nativeResponseValue;
3551 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner);
3553 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner: number): void {
3554 if(!isWasmInitialized) {
3555 throw new Error("initializeWasm() must be awaited first!");
3557 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner);
3558 // debug statements here
3560 // struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3562 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner: number): number {
3563 if(!isWasmInitialized) {
3564 throw new Error("initializeWasm() must be awaited first!");
3566 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner);
3567 return nativeResponseValue;
3569 // struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner);
3571 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner: number): number {
3572 if(!isWasmInitialized) {
3573 throw new Error("initializeWasm() must be awaited first!");
3575 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner);
3576 return nativeResponseValue;
3578 // struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3580 export function CResult_PaymentSecretNoneZ_get_ok(owner: number): number {
3581 if(!isWasmInitialized) {
3582 throw new Error("initializeWasm() must be awaited first!");
3584 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_ok(owner);
3585 return nativeResponseValue;
3587 // void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner);
3589 export function CResult_PaymentSecretNoneZ_get_err(owner: number): void {
3590 if(!isWasmInitialized) {
3591 throw new Error("initializeWasm() must be awaited first!");
3593 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_get_err(owner);
3594 // debug statements here
3596 // struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3598 export function CResult_PaymentSecretAPIErrorZ_get_ok(owner: number): number {
3599 if(!isWasmInitialized) {
3600 throw new Error("initializeWasm() must be awaited first!");
3602 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_ok(owner);
3603 return nativeResponseValue;
3605 // struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner);
3607 export function CResult_PaymentSecretAPIErrorZ_get_err(owner: number): number {
3608 if(!isWasmInitialized) {
3609 throw new Error("initializeWasm() must be awaited first!");
3611 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_get_err(owner);
3612 return nativeResponseValue;
3614 // struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3616 export function CResult_PaymentPreimageAPIErrorZ_get_ok(owner: number): number {
3617 if(!isWasmInitialized) {
3618 throw new Error("initializeWasm() must be awaited first!");
3620 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_ok(owner);
3621 return nativeResponseValue;
3623 // struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner);
3625 export function CResult_PaymentPreimageAPIErrorZ_get_err(owner: number): number {
3626 if(!isWasmInitialized) {
3627 throw new Error("initializeWasm() must be awaited first!");
3629 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_get_err(owner);
3630 return nativeResponseValue;
3632 // struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3634 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner: number): number {
3635 if(!isWasmInitialized) {
3636 throw new Error("initializeWasm() must be awaited first!");
3638 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner);
3639 return nativeResponseValue;
3641 // struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner);
3643 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner: number): number {
3644 if(!isWasmInitialized) {
3645 throw new Error("initializeWasm() must be awaited first!");
3647 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner);
3648 return nativeResponseValue;
3650 // struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3652 export function CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner: number): number {
3653 if(!isWasmInitialized) {
3654 throw new Error("initializeWasm() must be awaited first!");
3656 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner);
3657 return nativeResponseValue;
3659 // struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner);
3661 export function CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner: number): number {
3662 if(!isWasmInitialized) {
3663 throw new Error("initializeWasm() must be awaited first!");
3665 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner);
3666 return nativeResponseValue;
3668 // struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3670 export function CResult_ChannelDetailsDecodeErrorZ_get_ok(owner: number): number {
3671 if(!isWasmInitialized) {
3672 throw new Error("initializeWasm() must be awaited first!");
3674 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(owner);
3675 return nativeResponseValue;
3677 // struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner);
3679 export function CResult_ChannelDetailsDecodeErrorZ_get_err(owner: number): number {
3680 if(!isWasmInitialized) {
3681 throw new Error("initializeWasm() must be awaited first!");
3683 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_get_err(owner);
3684 return nativeResponseValue;
3686 // struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3688 export function CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner: number): number {
3689 if(!isWasmInitialized) {
3690 throw new Error("initializeWasm() must be awaited first!");
3692 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner);
3693 return nativeResponseValue;
3695 // struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner);
3697 export function CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner: number): number {
3698 if(!isWasmInitialized) {
3699 throw new Error("initializeWasm() must be awaited first!");
3701 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner);
3702 return nativeResponseValue;
3705 export interface LDKWatch {
3706 watch_channel (funding_txo: number, monitor: number): number;
3707 update_channel (funding_txo: number, update: number): number;
3708 release_pending_monitor_events (): number;
3712 export function LDKWatch_new(impl: LDKWatch): number {
3713 if(!isWasmInitialized) {
3714 throw new Error("initializeWasm() must be awaited first!");
3716 var new_obj_idx = js_objs.length;
3717 for (var i = 0; i < js_objs.length; i++) {
3718 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3720 js_objs[i] = new WeakRef(impl);
3721 return wasm.TS_LDKWatch_new(i);
3723 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
3725 export function Watch_watch_channel(this_arg: number, funding_txo: number, monitor: number): number {
3726 if(!isWasmInitialized) {
3727 throw new Error("initializeWasm() must be awaited first!");
3729 const nativeResponseValue = wasm.TS_Watch_watch_channel(this_arg, funding_txo, monitor);
3730 return nativeResponseValue;
3732 // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
3734 export function Watch_update_channel(this_arg: number, funding_txo: number, update: number): number {
3735 if(!isWasmInitialized) {
3736 throw new Error("initializeWasm() must be awaited first!");
3738 const nativeResponseValue = wasm.TS_Watch_update_channel(this_arg, funding_txo, update);
3739 return nativeResponseValue;
3741 // LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
3743 export function Watch_release_pending_monitor_events(this_arg: number): number {
3744 if(!isWasmInitialized) {
3745 throw new Error("initializeWasm() must be awaited first!");
3747 const nativeResponseValue = wasm.TS_Watch_release_pending_monitor_events(this_arg);
3748 return nativeResponseValue;
3751 export interface LDKBroadcasterInterface {
3752 broadcast_transaction (tx: number): void;
3756 export function LDKBroadcasterInterface_new(impl: LDKBroadcasterInterface): number {
3757 if(!isWasmInitialized) {
3758 throw new Error("initializeWasm() must be awaited first!");
3760 var new_obj_idx = js_objs.length;
3761 for (var i = 0; i < js_objs.length; i++) {
3762 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3764 js_objs[i] = new WeakRef(impl);
3765 return wasm.TS_LDKBroadcasterInterface_new(i);
3767 // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
3769 export function BroadcasterInterface_broadcast_transaction(this_arg: number, tx: number): void {
3770 if(!isWasmInitialized) {
3771 throw new Error("initializeWasm() must be awaited first!");
3773 const nativeResponseValue = wasm.TS_BroadcasterInterface_broadcast_transaction(this_arg, tx);
3774 // debug statements here
3777 export interface LDKKeysInterface {
3778 get_node_secret (recipient: Recipient): number;
3779 get_destination_script (): number;
3780 get_shutdown_scriptpubkey (): number;
3781 get_channel_signer (inbound: boolean, channel_value_satoshis: bigint): number;
3782 get_secure_random_bytes (): number;
3783 read_chan_signer (reader: number): number;
3784 sign_invoice (hrp_bytes: number, invoice_data: number, receipient: Recipient): number;
3785 get_inbound_payment_key_material (): number;
3789 export function LDKKeysInterface_new(impl: LDKKeysInterface): number {
3790 if(!isWasmInitialized) {
3791 throw new Error("initializeWasm() must be awaited first!");
3793 var new_obj_idx = js_objs.length;
3794 for (var i = 0; i < js_objs.length; i++) {
3795 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3797 js_objs[i] = new WeakRef(impl);
3798 return wasm.TS_LDKKeysInterface_new(i);
3800 // LDKCResult_SecretKeyNoneZ KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg, enum LDKRecipient recipient
3802 export function KeysInterface_get_node_secret(this_arg: number, recipient: Recipient): number {
3803 if(!isWasmInitialized) {
3804 throw new Error("initializeWasm() must be awaited first!");
3806 const nativeResponseValue = wasm.TS_KeysInterface_get_node_secret(this_arg, recipient);
3807 return nativeResponseValue;
3809 // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
3811 export function KeysInterface_get_destination_script(this_arg: number): number {
3812 if(!isWasmInitialized) {
3813 throw new Error("initializeWasm() must be awaited first!");
3815 const nativeResponseValue = wasm.TS_KeysInterface_get_destination_script(this_arg);
3816 return nativeResponseValue;
3818 // LDKShutdownScript KeysInterface_get_shutdown_scriptpubkey LDKKeysInterface *NONNULL_PTR this_arg
3820 export function KeysInterface_get_shutdown_scriptpubkey(this_arg: number): number {
3821 if(!isWasmInitialized) {
3822 throw new Error("initializeWasm() must be awaited first!");
3824 const nativeResponseValue = wasm.TS_KeysInterface_get_shutdown_scriptpubkey(this_arg);
3825 return nativeResponseValue;
3827 // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
3829 export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: bigint): number {
3830 if(!isWasmInitialized) {
3831 throw new Error("initializeWasm() must be awaited first!");
3833 const nativeResponseValue = wasm.TS_KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
3834 return nativeResponseValue;
3836 // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
3838 export function KeysInterface_get_secure_random_bytes(this_arg: number): number {
3839 if(!isWasmInitialized) {
3840 throw new Error("initializeWasm() must be awaited first!");
3842 const nativeResponseValue = wasm.TS_KeysInterface_get_secure_random_bytes(this_arg);
3843 return nativeResponseValue;
3845 // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
3847 export function KeysInterface_read_chan_signer(this_arg: number, reader: number): number {
3848 if(!isWasmInitialized) {
3849 throw new Error("initializeWasm() must be awaited first!");
3851 const nativeResponseValue = wasm.TS_KeysInterface_read_chan_signer(this_arg, reader);
3852 return nativeResponseValue;
3854 // LDKCResult_RecoverableSignatureNoneZ KeysInterface_sign_invoice LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z invoice_data, enum LDKRecipient receipient
3856 export function KeysInterface_sign_invoice(this_arg: number, hrp_bytes: number, invoice_data: number, receipient: Recipient): number {
3857 if(!isWasmInitialized) {
3858 throw new Error("initializeWasm() must be awaited first!");
3860 const nativeResponseValue = wasm.TS_KeysInterface_sign_invoice(this_arg, hrp_bytes, invoice_data, receipient);
3861 return nativeResponseValue;
3863 // LDKThirtyTwoBytes KeysInterface_get_inbound_payment_key_material LDKKeysInterface *NONNULL_PTR this_arg
3865 export function KeysInterface_get_inbound_payment_key_material(this_arg: number): number {
3866 if(!isWasmInitialized) {
3867 throw new Error("initializeWasm() must be awaited first!");
3869 const nativeResponseValue = wasm.TS_KeysInterface_get_inbound_payment_key_material(this_arg);
3870 return nativeResponseValue;
3873 export interface LDKFeeEstimator {
3874 get_est_sat_per_1000_weight (confirmation_target: ConfirmationTarget): number;
3878 export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
3879 if(!isWasmInitialized) {
3880 throw new Error("initializeWasm() must be awaited first!");
3882 var new_obj_idx = js_objs.length;
3883 for (var i = 0; i < js_objs.length; i++) {
3884 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3886 js_objs[i] = new WeakRef(impl);
3887 return wasm.TS_LDKFeeEstimator_new(i);
3889 // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
3891 export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: ConfirmationTarget): number {
3892 if(!isWasmInitialized) {
3893 throw new Error("initializeWasm() must be awaited first!");
3895 const nativeResponseValue = wasm.TS_FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
3896 return nativeResponseValue;
3898 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3900 export function C2Tuple_BlockHashChannelManagerZ_get_a(owner: number): number {
3901 if(!isWasmInitialized) {
3902 throw new Error("initializeWasm() must be awaited first!");
3904 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_a(owner);
3905 return nativeResponseValue;
3907 // struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner);
3909 export function C2Tuple_BlockHashChannelManagerZ_get_b(owner: number): number {
3910 if(!isWasmInitialized) {
3911 throw new Error("initializeWasm() must be awaited first!");
3913 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_get_b(owner);
3914 return nativeResponseValue;
3916 // struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3918 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner: number): number {
3919 if(!isWasmInitialized) {
3920 throw new Error("initializeWasm() must be awaited first!");
3922 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner);
3923 return nativeResponseValue;
3925 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner);
3927 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner: number): number {
3928 if(!isWasmInitialized) {
3929 throw new Error("initializeWasm() must be awaited first!");
3931 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner);
3932 return nativeResponseValue;
3934 // struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3936 export function CResult_ChannelConfigDecodeErrorZ_get_ok(owner: number): number {
3937 if(!isWasmInitialized) {
3938 throw new Error("initializeWasm() must be awaited first!");
3940 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_ok(owner);
3941 return nativeResponseValue;
3943 // struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner);
3945 export function CResult_ChannelConfigDecodeErrorZ_get_err(owner: number): number {
3946 if(!isWasmInitialized) {
3947 throw new Error("initializeWasm() must be awaited first!");
3949 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_get_err(owner);
3950 return nativeResponseValue;
3952 // struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3954 export function CResult_OutPointDecodeErrorZ_get_ok(owner: number): number {
3955 if(!isWasmInitialized) {
3956 throw new Error("initializeWasm() must be awaited first!");
3958 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_ok(owner);
3959 return nativeResponseValue;
3961 // struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner);
3963 export function CResult_OutPointDecodeErrorZ_get_err(owner: number): number {
3964 if(!isWasmInitialized) {
3965 throw new Error("initializeWasm() must be awaited first!");
3967 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_get_err(owner);
3968 return nativeResponseValue;
3971 export interface LDKType {
3973 debug_str (): number;
3978 export function LDKType_new(impl: LDKType): number {
3979 if(!isWasmInitialized) {
3980 throw new Error("initializeWasm() must be awaited first!");
3982 var new_obj_idx = js_objs.length;
3983 for (var i = 0; i < js_objs.length; i++) {
3984 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
3986 js_objs[i] = new WeakRef(impl);
3987 return wasm.TS_LDKType_new(i);
3989 // uint16_t Type_type_id LDKType *NONNULL_PTR this_arg
3991 export function Type_type_id(this_arg: number): number {
3992 if(!isWasmInitialized) {
3993 throw new Error("initializeWasm() must be awaited first!");
3995 const nativeResponseValue = wasm.TS_Type_type_id(this_arg);
3996 return nativeResponseValue;
3998 // LDKStr Type_debug_str LDKType *NONNULL_PTR this_arg
4000 export function Type_debug_str(this_arg: number): number {
4001 if(!isWasmInitialized) {
4002 throw new Error("initializeWasm() must be awaited first!");
4004 const nativeResponseValue = wasm.TS_Type_debug_str(this_arg);
4005 return nativeResponseValue;
4007 // LDKCVec_u8Z Type_write LDKType *NONNULL_PTR this_arg
4009 export function Type_write(this_arg: number): number {
4010 if(!isWasmInitialized) {
4011 throw new Error("initializeWasm() must be awaited first!");
4013 const nativeResponseValue = wasm.TS_Type_write(this_arg);
4014 return nativeResponseValue;
4017 export class LDKCOption_TypeZ {
4018 protected constructor() {}
4021 export function LDKCOption_TypeZ_ty_from_ptr(ptr: number): number {
4022 if(!isWasmInitialized) {
4023 throw new Error("initializeWasm() must be awaited first!");
4025 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_ty_from_ptr(ptr);
4026 return nativeResponseValue;
4029 export function LDKCOption_TypeZ_Some_get_some(ptr: number): number {
4030 if(!isWasmInitialized) {
4031 throw new Error("initializeWasm() must be awaited first!");
4033 const nativeResponseValue = wasm.TS_LDKCOption_TypeZ_Some_get_some(ptr);
4034 return nativeResponseValue;
4036 // struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4038 export function CResult_COption_TypeZDecodeErrorZ_get_ok(owner: number): number {
4039 if(!isWasmInitialized) {
4040 throw new Error("initializeWasm() must be awaited first!");
4042 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_ok(owner);
4043 return nativeResponseValue;
4045 // struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner);
4047 export function CResult_COption_TypeZDecodeErrorZ_get_err(owner: number): number {
4048 if(!isWasmInitialized) {
4049 throw new Error("initializeWasm() must be awaited first!");
4051 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_get_err(owner);
4052 return nativeResponseValue;
4055 export class LDKPaymentError {
4056 protected constructor() {}
4059 export function LDKPaymentError_ty_from_ptr(ptr: number): number {
4060 if(!isWasmInitialized) {
4061 throw new Error("initializeWasm() must be awaited first!");
4063 const nativeResponseValue = wasm.TS_LDKPaymentError_ty_from_ptr(ptr);
4064 return nativeResponseValue;
4067 export function LDKPaymentError_Invoice_get_invoice(ptr: number): number {
4068 if(!isWasmInitialized) {
4069 throw new Error("initializeWasm() must be awaited first!");
4071 const nativeResponseValue = wasm.TS_LDKPaymentError_Invoice_get_invoice(ptr);
4072 return nativeResponseValue;
4075 export function LDKPaymentError_Routing_get_routing(ptr: number): number {
4076 if(!isWasmInitialized) {
4077 throw new Error("initializeWasm() must be awaited first!");
4079 const nativeResponseValue = wasm.TS_LDKPaymentError_Routing_get_routing(ptr);
4080 return nativeResponseValue;
4083 export function LDKPaymentError_Sending_get_sending(ptr: number): number {
4084 if(!isWasmInitialized) {
4085 throw new Error("initializeWasm() must be awaited first!");
4087 const nativeResponseValue = wasm.TS_LDKPaymentError_Sending_get_sending(ptr);
4088 return nativeResponseValue;
4090 // struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4092 export function CResult_PaymentIdPaymentErrorZ_get_ok(owner: number): number {
4093 if(!isWasmInitialized) {
4094 throw new Error("initializeWasm() must be awaited first!");
4096 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_ok(owner);
4097 return nativeResponseValue;
4099 // struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner);
4101 export function CResult_PaymentIdPaymentErrorZ_get_err(owner: number): number {
4102 if(!isWasmInitialized) {
4103 throw new Error("initializeWasm() must be awaited first!");
4105 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_get_err(owner);
4106 return nativeResponseValue;
4109 export class LDKParseError {
4110 protected constructor() {}
4113 export function LDKParseError_ty_from_ptr(ptr: number): number {
4114 if(!isWasmInitialized) {
4115 throw new Error("initializeWasm() must be awaited first!");
4117 const nativeResponseValue = wasm.TS_LDKParseError_ty_from_ptr(ptr);
4118 return nativeResponseValue;
4121 export function LDKParseError_Bech32Error_get_bech32_error(ptr: number): number {
4122 if(!isWasmInitialized) {
4123 throw new Error("initializeWasm() must be awaited first!");
4125 const nativeResponseValue = wasm.TS_LDKParseError_Bech32Error_get_bech32_error(ptr);
4126 return nativeResponseValue;
4129 export function LDKParseError_ParseAmountError_get_parse_amount_error(ptr: number): number {
4130 if(!isWasmInitialized) {
4131 throw new Error("initializeWasm() must be awaited first!");
4133 const nativeResponseValue = wasm.TS_LDKParseError_ParseAmountError_get_parse_amount_error(ptr);
4134 return nativeResponseValue;
4137 export function LDKParseError_MalformedSignature_get_malformed_signature(ptr: number): Secp256k1Error {
4138 if(!isWasmInitialized) {
4139 throw new Error("initializeWasm() must be awaited first!");
4141 const nativeResponseValue = wasm.TS_LDKParseError_MalformedSignature_get_malformed_signature(ptr);
4142 return nativeResponseValue;
4145 export function LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr: number): number {
4146 if(!isWasmInitialized) {
4147 throw new Error("initializeWasm() must be awaited first!");
4149 const nativeResponseValue = wasm.TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(ptr);
4150 return nativeResponseValue;
4153 export function LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr: number): number {
4154 if(!isWasmInitialized) {
4155 throw new Error("initializeWasm() must be awaited first!");
4157 const nativeResponseValue = wasm.TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(ptr);
4158 return nativeResponseValue;
4160 // enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4162 export function CResult_SiPrefixParseErrorZ_get_ok(owner: number): SiPrefix {
4163 if(!isWasmInitialized) {
4164 throw new Error("initializeWasm() must be awaited first!");
4166 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_ok(owner);
4167 return nativeResponseValue;
4169 // struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner);
4171 export function CResult_SiPrefixParseErrorZ_get_err(owner: number): number {
4172 if(!isWasmInitialized) {
4173 throw new Error("initializeWasm() must be awaited first!");
4175 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_get_err(owner);
4176 return nativeResponseValue;
4179 export class LDKParseOrSemanticError {
4180 protected constructor() {}
4183 export function LDKParseOrSemanticError_ty_from_ptr(ptr: number): number {
4184 if(!isWasmInitialized) {
4185 throw new Error("initializeWasm() must be awaited first!");
4187 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ty_from_ptr(ptr);
4188 return nativeResponseValue;
4191 export function LDKParseOrSemanticError_ParseError_get_parse_error(ptr: number): number {
4192 if(!isWasmInitialized) {
4193 throw new Error("initializeWasm() must be awaited first!");
4195 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_ParseError_get_parse_error(ptr);
4196 return nativeResponseValue;
4199 export function LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr: number): SemanticError {
4200 if(!isWasmInitialized) {
4201 throw new Error("initializeWasm() must be awaited first!");
4203 const nativeResponseValue = wasm.TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(ptr);
4204 return nativeResponseValue;
4206 // struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4208 export function CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner: number): number {
4209 if(!isWasmInitialized) {
4210 throw new Error("initializeWasm() must be awaited first!");
4212 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner);
4213 return nativeResponseValue;
4215 // struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner);
4217 export function CResult_InvoiceParseOrSemanticErrorZ_get_err(owner: number): number {
4218 if(!isWasmInitialized) {
4219 throw new Error("initializeWasm() must be awaited first!");
4221 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(owner);
4222 return nativeResponseValue;
4224 // struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4226 export function CResult_SignedRawInvoiceParseErrorZ_get_ok(owner: number): number {
4227 if(!isWasmInitialized) {
4228 throw new Error("initializeWasm() must be awaited first!");
4230 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(owner);
4231 return nativeResponseValue;
4233 // struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner);
4235 export function CResult_SignedRawInvoiceParseErrorZ_get_err(owner: number): number {
4236 if(!isWasmInitialized) {
4237 throw new Error("initializeWasm() must be awaited first!");
4239 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_get_err(owner);
4240 return nativeResponseValue;
4242 // struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4244 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner: number): number {
4245 if(!isWasmInitialized) {
4246 throw new Error("initializeWasm() must be awaited first!");
4248 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner);
4249 return nativeResponseValue;
4251 // struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4253 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner: number): number {
4254 if(!isWasmInitialized) {
4255 throw new Error("initializeWasm() must be awaited first!");
4257 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner);
4258 return nativeResponseValue;
4260 // struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner);
4262 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner: number): number {
4263 if(!isWasmInitialized) {
4264 throw new Error("initializeWasm() must be awaited first!");
4266 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner);
4267 return nativeResponseValue;
4269 // struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4271 export function CResult_PayeePubKeyErrorZ_get_ok(owner: number): number {
4272 if(!isWasmInitialized) {
4273 throw new Error("initializeWasm() must be awaited first!");
4275 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_ok(owner);
4276 return nativeResponseValue;
4278 // enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner);
4280 export function CResult_PayeePubKeyErrorZ_get_err(owner: number): Secp256k1Error {
4281 if(!isWasmInitialized) {
4282 throw new Error("initializeWasm() must be awaited first!");
4284 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_get_err(owner);
4285 return nativeResponseValue;
4287 // struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4289 export function CResult_PositiveTimestampCreationErrorZ_get_ok(owner: number): number {
4290 if(!isWasmInitialized) {
4291 throw new Error("initializeWasm() must be awaited first!");
4293 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_ok(owner);
4294 return nativeResponseValue;
4296 // enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner);
4298 export function CResult_PositiveTimestampCreationErrorZ_get_err(owner: number): CreationError {
4299 if(!isWasmInitialized) {
4300 throw new Error("initializeWasm() must be awaited first!");
4302 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_get_err(owner);
4303 return nativeResponseValue;
4305 // void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4307 export function CResult_NoneSemanticErrorZ_get_ok(owner: number): void {
4308 if(!isWasmInitialized) {
4309 throw new Error("initializeWasm() must be awaited first!");
4311 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_ok(owner);
4312 // debug statements here
4314 // enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner);
4316 export function CResult_NoneSemanticErrorZ_get_err(owner: number): SemanticError {
4317 if(!isWasmInitialized) {
4318 throw new Error("initializeWasm() must be awaited first!");
4320 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_get_err(owner);
4321 return nativeResponseValue;
4323 // struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4325 export function CResult_InvoiceSemanticErrorZ_get_ok(owner: number): number {
4326 if(!isWasmInitialized) {
4327 throw new Error("initializeWasm() must be awaited first!");
4329 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_ok(owner);
4330 return nativeResponseValue;
4332 // enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner);
4334 export function CResult_InvoiceSemanticErrorZ_get_err(owner: number): SemanticError {
4335 if(!isWasmInitialized) {
4336 throw new Error("initializeWasm() must be awaited first!");
4338 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_get_err(owner);
4339 return nativeResponseValue;
4341 // struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4343 export function CResult_DescriptionCreationErrorZ_get_ok(owner: number): number {
4344 if(!isWasmInitialized) {
4345 throw new Error("initializeWasm() must be awaited first!");
4347 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_ok(owner);
4348 return nativeResponseValue;
4350 // enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner);
4352 export function CResult_DescriptionCreationErrorZ_get_err(owner: number): CreationError {
4353 if(!isWasmInitialized) {
4354 throw new Error("initializeWasm() must be awaited first!");
4356 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_get_err(owner);
4357 return nativeResponseValue;
4359 // struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4361 export function CResult_PrivateRouteCreationErrorZ_get_ok(owner: number): number {
4362 if(!isWasmInitialized) {
4363 throw new Error("initializeWasm() must be awaited first!");
4365 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_ok(owner);
4366 return nativeResponseValue;
4368 // enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner);
4370 export function CResult_PrivateRouteCreationErrorZ_get_err(owner: number): CreationError {
4371 if(!isWasmInitialized) {
4372 throw new Error("initializeWasm() must be awaited first!");
4374 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_get_err(owner);
4375 return nativeResponseValue;
4377 // struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4379 export function CResult_StringErrorZ_get_ok(owner: number): number {
4380 if(!isWasmInitialized) {
4381 throw new Error("initializeWasm() must be awaited first!");
4383 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_ok(owner);
4384 return nativeResponseValue;
4386 // enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner);
4388 export function CResult_StringErrorZ_get_err(owner: number): Secp256k1Error {
4389 if(!isWasmInitialized) {
4390 throw new Error("initializeWasm() must be awaited first!");
4392 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_get_err(owner);
4393 return nativeResponseValue;
4395 // struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4397 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner: number): number {
4398 if(!isWasmInitialized) {
4399 throw new Error("initializeWasm() must be awaited first!");
4401 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner);
4402 return nativeResponseValue;
4404 // struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner);
4406 export function CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner: number): number {
4407 if(!isWasmInitialized) {
4408 throw new Error("initializeWasm() must be awaited first!");
4410 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner);
4411 return nativeResponseValue;
4414 export class LDKCOption_MonitorEventZ {
4415 protected constructor() {}
4418 export function LDKCOption_MonitorEventZ_ty_from_ptr(ptr: number): number {
4419 if(!isWasmInitialized) {
4420 throw new Error("initializeWasm() must be awaited first!");
4422 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_ty_from_ptr(ptr);
4423 return nativeResponseValue;
4426 export function LDKCOption_MonitorEventZ_Some_get_some(ptr: number): number {
4427 if(!isWasmInitialized) {
4428 throw new Error("initializeWasm() must be awaited first!");
4430 const nativeResponseValue = wasm.TS_LDKCOption_MonitorEventZ_Some_get_some(ptr);
4431 return nativeResponseValue;
4433 // struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4435 export function CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner: number): number {
4436 if(!isWasmInitialized) {
4437 throw new Error("initializeWasm() must be awaited first!");
4439 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner);
4440 return nativeResponseValue;
4442 // struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner);
4444 export function CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner: number): number {
4445 if(!isWasmInitialized) {
4446 throw new Error("initializeWasm() must be awaited first!");
4448 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner);
4449 return nativeResponseValue;
4451 // struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4453 export function CResult_HTLCUpdateDecodeErrorZ_get_ok(owner: number): number {
4454 if(!isWasmInitialized) {
4455 throw new Error("initializeWasm() must be awaited first!");
4457 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(owner);
4458 return nativeResponseValue;
4460 // struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner);
4462 export function CResult_HTLCUpdateDecodeErrorZ_get_err(owner: number): number {
4463 if(!isWasmInitialized) {
4464 throw new Error("initializeWasm() must be awaited first!");
4466 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_get_err(owner);
4467 return nativeResponseValue;
4469 // struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4471 export function C2Tuple_OutPointScriptZ_get_a(owner: number): number {
4472 if(!isWasmInitialized) {
4473 throw new Error("initializeWasm() must be awaited first!");
4475 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_a(owner);
4476 return nativeResponseValue;
4478 // struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner);
4480 export function C2Tuple_OutPointScriptZ_get_b(owner: number): number {
4481 if(!isWasmInitialized) {
4482 throw new Error("initializeWasm() must be awaited first!");
4484 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_get_b(owner);
4485 return nativeResponseValue;
4487 // uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4489 export function C2Tuple_u32ScriptZ_get_a(owner: number): number {
4490 if(!isWasmInitialized) {
4491 throw new Error("initializeWasm() must be awaited first!");
4493 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_a(owner);
4494 return nativeResponseValue;
4496 // struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner);
4498 export function C2Tuple_u32ScriptZ_get_b(owner: number): number {
4499 if(!isWasmInitialized) {
4500 throw new Error("initializeWasm() must be awaited first!");
4502 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_get_b(owner);
4503 return nativeResponseValue;
4505 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4507 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner: number): number {
4508 if(!isWasmInitialized) {
4509 throw new Error("initializeWasm() must be awaited first!");
4511 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner);
4512 return nativeResponseValue;
4514 // struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner);
4516 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner: number): number {
4517 if(!isWasmInitialized) {
4518 throw new Error("initializeWasm() must be awaited first!");
4520 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner);
4521 return nativeResponseValue;
4523 // uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4525 export function C2Tuple_u32TxOutZ_get_a(owner: number): number {
4526 if(!isWasmInitialized) {
4527 throw new Error("initializeWasm() must be awaited first!");
4529 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_a(owner);
4530 return nativeResponseValue;
4532 // struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner);
4534 export function C2Tuple_u32TxOutZ_get_b(owner: number): number {
4535 if(!isWasmInitialized) {
4536 throw new Error("initializeWasm() must be awaited first!");
4538 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_get_b(owner);
4539 return nativeResponseValue;
4541 // struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4543 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner: number): number {
4544 if(!isWasmInitialized) {
4545 throw new Error("initializeWasm() must be awaited first!");
4547 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner);
4548 return nativeResponseValue;
4550 // struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner);
4552 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner: number): number {
4553 if(!isWasmInitialized) {
4554 throw new Error("initializeWasm() must be awaited first!");
4556 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner);
4557 return nativeResponseValue;
4560 export class LDKBalance {
4561 protected constructor() {}
4564 export function LDKBalance_ty_from_ptr(ptr: number): number {
4565 if(!isWasmInitialized) {
4566 throw new Error("initializeWasm() must be awaited first!");
4568 const nativeResponseValue = wasm.TS_LDKBalance_ty_from_ptr(ptr);
4569 return nativeResponseValue;
4572 export function LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr: number): bigint {
4573 if(!isWasmInitialized) {
4574 throw new Error("initializeWasm() must be awaited first!");
4576 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(ptr);
4577 return nativeResponseValue;
4580 export function LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr: number): bigint {
4581 if(!isWasmInitialized) {
4582 throw new Error("initializeWasm() must be awaited first!");
4584 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(ptr);
4585 return nativeResponseValue;
4588 export function LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr: number): number {
4589 if(!isWasmInitialized) {
4590 throw new Error("initializeWasm() must be awaited first!");
4592 const nativeResponseValue = wasm.TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(ptr);
4593 return nativeResponseValue;
4596 export function LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr: number): bigint {
4597 if(!isWasmInitialized) {
4598 throw new Error("initializeWasm() must be awaited first!");
4600 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(ptr);
4601 return nativeResponseValue;
4604 export function LDKBalance_ContentiousClaimable_get_timeout_height(ptr: number): number {
4605 if(!isWasmInitialized) {
4606 throw new Error("initializeWasm() must be awaited first!");
4608 const nativeResponseValue = wasm.TS_LDKBalance_ContentiousClaimable_get_timeout_height(ptr);
4609 return nativeResponseValue;
4612 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr: number): bigint {
4613 if(!isWasmInitialized) {
4614 throw new Error("initializeWasm() must be awaited first!");
4616 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(ptr);
4617 return nativeResponseValue;
4620 export function LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr: number): number {
4621 if(!isWasmInitialized) {
4622 throw new Error("initializeWasm() must be awaited first!");
4624 const nativeResponseValue = wasm.TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(ptr);
4625 return nativeResponseValue;
4627 // struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4629 export function C2Tuple_BlockHashChannelMonitorZ_get_a(owner: number): number {
4630 if(!isWasmInitialized) {
4631 throw new Error("initializeWasm() must be awaited first!");
4633 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_a(owner);
4634 return nativeResponseValue;
4636 // struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner);
4638 export function C2Tuple_BlockHashChannelMonitorZ_get_b(owner: number): number {
4639 if(!isWasmInitialized) {
4640 throw new Error("initializeWasm() must be awaited first!");
4642 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_get_b(owner);
4643 return nativeResponseValue;
4645 // struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4647 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner: number): number {
4648 if(!isWasmInitialized) {
4649 throw new Error("initializeWasm() must be awaited first!");
4651 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner);
4652 return nativeResponseValue;
4654 // struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner);
4656 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner: number): number {
4657 if(!isWasmInitialized) {
4658 throw new Error("initializeWasm() must be awaited first!");
4660 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner);
4661 return nativeResponseValue;
4663 // struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4665 export function C2Tuple_PublicKeyTypeZ_get_a(owner: number): number {
4666 if(!isWasmInitialized) {
4667 throw new Error("initializeWasm() must be awaited first!");
4669 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_a(owner);
4670 return nativeResponseValue;
4672 // struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner);
4674 export function C2Tuple_PublicKeyTypeZ_get_b(owner: number): number {
4675 if(!isWasmInitialized) {
4676 throw new Error("initializeWasm() must be awaited first!");
4678 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_get_b(owner);
4679 return nativeResponseValue;
4682 export class LDKCOption_NetAddressZ {
4683 protected constructor() {}
4686 export function LDKCOption_NetAddressZ_ty_from_ptr(ptr: number): number {
4687 if(!isWasmInitialized) {
4688 throw new Error("initializeWasm() must be awaited first!");
4690 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_ty_from_ptr(ptr);
4691 return nativeResponseValue;
4694 export function LDKCOption_NetAddressZ_Some_get_some(ptr: number): number {
4695 if(!isWasmInitialized) {
4696 throw new Error("initializeWasm() must be awaited first!");
4698 const nativeResponseValue = wasm.TS_LDKCOption_NetAddressZ_Some_get_some(ptr);
4699 return nativeResponseValue;
4701 // struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4703 export function CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner: number): number {
4704 if(!isWasmInitialized) {
4705 throw new Error("initializeWasm() must be awaited first!");
4707 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner);
4708 return nativeResponseValue;
4710 // struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner);
4712 export function CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner: number): number {
4713 if(!isWasmInitialized) {
4714 throw new Error("initializeWasm() must be awaited first!");
4716 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner);
4717 return nativeResponseValue;
4719 // void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4721 export function CResult_NonePeerHandleErrorZ_get_ok(owner: number): void {
4722 if(!isWasmInitialized) {
4723 throw new Error("initializeWasm() must be awaited first!");
4725 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_ok(owner);
4726 // debug statements here
4728 // struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner);
4730 export function CResult_NonePeerHandleErrorZ_get_err(owner: number): number {
4731 if(!isWasmInitialized) {
4732 throw new Error("initializeWasm() must be awaited first!");
4734 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_get_err(owner);
4735 return nativeResponseValue;
4737 // bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4739 export function CResult_boolPeerHandleErrorZ_get_ok(owner: number): boolean {
4740 if(!isWasmInitialized) {
4741 throw new Error("initializeWasm() must be awaited first!");
4743 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_ok(owner);
4744 return nativeResponseValue;
4746 // struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner);
4748 export function CResult_boolPeerHandleErrorZ_get_err(owner: number): number {
4749 if(!isWasmInitialized) {
4750 throw new Error("initializeWasm() must be awaited first!");
4752 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_get_err(owner);
4753 return nativeResponseValue;
4755 // void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4757 export function CResult_NoneErrorZ_get_ok(owner: number): void {
4758 if(!isWasmInitialized) {
4759 throw new Error("initializeWasm() must be awaited first!");
4761 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_ok(owner);
4762 // debug statements here
4764 // enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner);
4766 export function CResult_NoneErrorZ_get_err(owner: number): IOError {
4767 if(!isWasmInitialized) {
4768 throw new Error("initializeWasm() must be awaited first!");
4770 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_get_err(owner);
4771 return nativeResponseValue;
4773 // struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4775 export function CResult_NetAddressDecodeErrorZ_get_ok(owner: number): number {
4776 if(!isWasmInitialized) {
4777 throw new Error("initializeWasm() must be awaited first!");
4779 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_ok(owner);
4780 return nativeResponseValue;
4782 // struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner);
4784 export function CResult_NetAddressDecodeErrorZ_get_err(owner: number): number {
4785 if(!isWasmInitialized) {
4786 throw new Error("initializeWasm() must be awaited first!");
4788 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_get_err(owner);
4789 return nativeResponseValue;
4791 // struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4793 export function CResult_AcceptChannelDecodeErrorZ_get_ok(owner: number): number {
4794 if(!isWasmInitialized) {
4795 throw new Error("initializeWasm() must be awaited first!");
4797 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_ok(owner);
4798 return nativeResponseValue;
4800 // struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner);
4802 export function CResult_AcceptChannelDecodeErrorZ_get_err(owner: number): number {
4803 if(!isWasmInitialized) {
4804 throw new Error("initializeWasm() must be awaited first!");
4806 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_get_err(owner);
4807 return nativeResponseValue;
4809 // struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4811 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner: number): number {
4812 if(!isWasmInitialized) {
4813 throw new Error("initializeWasm() must be awaited first!");
4815 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner);
4816 return nativeResponseValue;
4818 // struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner);
4820 export function CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner: number): number {
4821 if(!isWasmInitialized) {
4822 throw new Error("initializeWasm() must be awaited first!");
4824 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner);
4825 return nativeResponseValue;
4827 // struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4829 export function CResult_ChannelReestablishDecodeErrorZ_get_ok(owner: number): number {
4830 if(!isWasmInitialized) {
4831 throw new Error("initializeWasm() must be awaited first!");
4833 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(owner);
4834 return nativeResponseValue;
4836 // struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner);
4838 export function CResult_ChannelReestablishDecodeErrorZ_get_err(owner: number): number {
4839 if(!isWasmInitialized) {
4840 throw new Error("initializeWasm() must be awaited first!");
4842 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_get_err(owner);
4843 return nativeResponseValue;
4845 // struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4847 export function CResult_ClosingSignedDecodeErrorZ_get_ok(owner: number): number {
4848 if(!isWasmInitialized) {
4849 throw new Error("initializeWasm() must be awaited first!");
4851 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_ok(owner);
4852 return nativeResponseValue;
4854 // struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner);
4856 export function CResult_ClosingSignedDecodeErrorZ_get_err(owner: number): number {
4857 if(!isWasmInitialized) {
4858 throw new Error("initializeWasm() must be awaited first!");
4860 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_get_err(owner);
4861 return nativeResponseValue;
4863 // struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4865 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner: number): number {
4866 if(!isWasmInitialized) {
4867 throw new Error("initializeWasm() must be awaited first!");
4869 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner);
4870 return nativeResponseValue;
4872 // struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner);
4874 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner: number): number {
4875 if(!isWasmInitialized) {
4876 throw new Error("initializeWasm() must be awaited first!");
4878 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner);
4879 return nativeResponseValue;
4881 // struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4883 export function CResult_CommitmentSignedDecodeErrorZ_get_ok(owner: number): number {
4884 if(!isWasmInitialized) {
4885 throw new Error("initializeWasm() must be awaited first!");
4887 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(owner);
4888 return nativeResponseValue;
4890 // struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner);
4892 export function CResult_CommitmentSignedDecodeErrorZ_get_err(owner: number): number {
4893 if(!isWasmInitialized) {
4894 throw new Error("initializeWasm() must be awaited first!");
4896 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_get_err(owner);
4897 return nativeResponseValue;
4899 // struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4901 export function CResult_FundingCreatedDecodeErrorZ_get_ok(owner: number): number {
4902 if(!isWasmInitialized) {
4903 throw new Error("initializeWasm() must be awaited first!");
4905 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_ok(owner);
4906 return nativeResponseValue;
4908 // struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner);
4910 export function CResult_FundingCreatedDecodeErrorZ_get_err(owner: number): number {
4911 if(!isWasmInitialized) {
4912 throw new Error("initializeWasm() must be awaited first!");
4914 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_get_err(owner);
4915 return nativeResponseValue;
4917 // struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4919 export function CResult_FundingSignedDecodeErrorZ_get_ok(owner: number): number {
4920 if(!isWasmInitialized) {
4921 throw new Error("initializeWasm() must be awaited first!");
4923 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_ok(owner);
4924 return nativeResponseValue;
4926 // struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner);
4928 export function CResult_FundingSignedDecodeErrorZ_get_err(owner: number): number {
4929 if(!isWasmInitialized) {
4930 throw new Error("initializeWasm() must be awaited first!");
4932 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_get_err(owner);
4933 return nativeResponseValue;
4935 // struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
4937 export function CResult_ChannelReadyDecodeErrorZ_get_ok(owner: number): number {
4938 if(!isWasmInitialized) {
4939 throw new Error("initializeWasm() must be awaited first!");
4941 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_ok(owner);
4942 return nativeResponseValue;
4944 // struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner);
4946 export function CResult_ChannelReadyDecodeErrorZ_get_err(owner: number): number {
4947 if(!isWasmInitialized) {
4948 throw new Error("initializeWasm() must be awaited first!");
4950 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_get_err(owner);
4951 return nativeResponseValue;
4953 // struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4955 export function CResult_InitDecodeErrorZ_get_ok(owner: number): number {
4956 if(!isWasmInitialized) {
4957 throw new Error("initializeWasm() must be awaited first!");
4959 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_ok(owner);
4960 return nativeResponseValue;
4962 // struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner);
4964 export function CResult_InitDecodeErrorZ_get_err(owner: number): number {
4965 if(!isWasmInitialized) {
4966 throw new Error("initializeWasm() must be awaited first!");
4968 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_get_err(owner);
4969 return nativeResponseValue;
4971 // struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
4973 export function CResult_OpenChannelDecodeErrorZ_get_ok(owner: number): number {
4974 if(!isWasmInitialized) {
4975 throw new Error("initializeWasm() must be awaited first!");
4977 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_ok(owner);
4978 return nativeResponseValue;
4980 // struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner);
4982 export function CResult_OpenChannelDecodeErrorZ_get_err(owner: number): number {
4983 if(!isWasmInitialized) {
4984 throw new Error("initializeWasm() must be awaited first!");
4986 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_get_err(owner);
4987 return nativeResponseValue;
4989 // struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
4991 export function CResult_RevokeAndACKDecodeErrorZ_get_ok(owner: number): number {
4992 if(!isWasmInitialized) {
4993 throw new Error("initializeWasm() must be awaited first!");
4995 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(owner);
4996 return nativeResponseValue;
4998 // struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner);
5000 export function CResult_RevokeAndACKDecodeErrorZ_get_err(owner: number): number {
5001 if(!isWasmInitialized) {
5002 throw new Error("initializeWasm() must be awaited first!");
5004 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_get_err(owner);
5005 return nativeResponseValue;
5007 // struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5009 export function CResult_ShutdownDecodeErrorZ_get_ok(owner: number): number {
5010 if(!isWasmInitialized) {
5011 throw new Error("initializeWasm() must be awaited first!");
5013 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_ok(owner);
5014 return nativeResponseValue;
5016 // struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner);
5018 export function CResult_ShutdownDecodeErrorZ_get_err(owner: number): number {
5019 if(!isWasmInitialized) {
5020 throw new Error("initializeWasm() must be awaited first!");
5022 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_get_err(owner);
5023 return nativeResponseValue;
5025 // struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5027 export function CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner: number): number {
5028 if(!isWasmInitialized) {
5029 throw new Error("initializeWasm() must be awaited first!");
5031 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner);
5032 return nativeResponseValue;
5034 // struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner);
5036 export function CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner: number): number {
5037 if(!isWasmInitialized) {
5038 throw new Error("initializeWasm() must be awaited first!");
5040 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner);
5041 return nativeResponseValue;
5043 // struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5045 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner: number): number {
5046 if(!isWasmInitialized) {
5047 throw new Error("initializeWasm() must be awaited first!");
5049 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner);
5050 return nativeResponseValue;
5052 // struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner);
5054 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner: number): number {
5055 if(!isWasmInitialized) {
5056 throw new Error("initializeWasm() must be awaited first!");
5058 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner);
5059 return nativeResponseValue;
5061 // struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5063 export function CResult_UpdateFeeDecodeErrorZ_get_ok(owner: number): number {
5064 if(!isWasmInitialized) {
5065 throw new Error("initializeWasm() must be awaited first!");
5067 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_ok(owner);
5068 return nativeResponseValue;
5070 // struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner);
5072 export function CResult_UpdateFeeDecodeErrorZ_get_err(owner: number): number {
5073 if(!isWasmInitialized) {
5074 throw new Error("initializeWasm() must be awaited first!");
5076 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_get_err(owner);
5077 return nativeResponseValue;
5079 // struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5081 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner: number): number {
5082 if(!isWasmInitialized) {
5083 throw new Error("initializeWasm() must be awaited first!");
5085 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner);
5086 return nativeResponseValue;
5088 // struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner);
5090 export function CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner: number): number {
5091 if(!isWasmInitialized) {
5092 throw new Error("initializeWasm() must be awaited first!");
5094 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner);
5095 return nativeResponseValue;
5097 // struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5099 export function CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner: number): number {
5100 if(!isWasmInitialized) {
5101 throw new Error("initializeWasm() must be awaited first!");
5103 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner);
5104 return nativeResponseValue;
5106 // struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner);
5108 export function CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner: number): number {
5109 if(!isWasmInitialized) {
5110 throw new Error("initializeWasm() must be awaited first!");
5112 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner);
5113 return nativeResponseValue;
5115 // struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5117 export function CResult_PingDecodeErrorZ_get_ok(owner: number): number {
5118 if(!isWasmInitialized) {
5119 throw new Error("initializeWasm() must be awaited first!");
5121 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_ok(owner);
5122 return nativeResponseValue;
5124 // struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner);
5126 export function CResult_PingDecodeErrorZ_get_err(owner: number): number {
5127 if(!isWasmInitialized) {
5128 throw new Error("initializeWasm() must be awaited first!");
5130 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_get_err(owner);
5131 return nativeResponseValue;
5133 // struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5135 export function CResult_PongDecodeErrorZ_get_ok(owner: number): number {
5136 if(!isWasmInitialized) {
5137 throw new Error("initializeWasm() must be awaited first!");
5139 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_ok(owner);
5140 return nativeResponseValue;
5142 // struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner);
5144 export function CResult_PongDecodeErrorZ_get_err(owner: number): number {
5145 if(!isWasmInitialized) {
5146 throw new Error("initializeWasm() must be awaited first!");
5148 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_get_err(owner);
5149 return nativeResponseValue;
5151 // struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5153 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5154 if(!isWasmInitialized) {
5155 throw new Error("initializeWasm() must be awaited first!");
5157 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner);
5158 return nativeResponseValue;
5160 // struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5162 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5163 if(!isWasmInitialized) {
5164 throw new Error("initializeWasm() must be awaited first!");
5166 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner);
5167 return nativeResponseValue;
5169 // struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5171 export function CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5172 if(!isWasmInitialized) {
5173 throw new Error("initializeWasm() must be awaited first!");
5175 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner);
5176 return nativeResponseValue;
5178 // struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5180 export function CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner: number): number {
5181 if(!isWasmInitialized) {
5182 throw new Error("initializeWasm() must be awaited first!");
5184 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner);
5185 return nativeResponseValue;
5187 // struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5189 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5190 if(!isWasmInitialized) {
5191 throw new Error("initializeWasm() must be awaited first!");
5193 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner);
5194 return nativeResponseValue;
5196 // struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5198 export function CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5199 if(!isWasmInitialized) {
5200 throw new Error("initializeWasm() must be awaited first!");
5202 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner);
5203 return nativeResponseValue;
5205 // struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5207 export function CResult_ChannelUpdateDecodeErrorZ_get_ok(owner: number): number {
5208 if(!isWasmInitialized) {
5209 throw new Error("initializeWasm() must be awaited first!");
5211 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(owner);
5212 return nativeResponseValue;
5214 // struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner);
5216 export function CResult_ChannelUpdateDecodeErrorZ_get_err(owner: number): number {
5217 if(!isWasmInitialized) {
5218 throw new Error("initializeWasm() must be awaited first!");
5220 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_get_err(owner);
5221 return nativeResponseValue;
5223 // struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5225 export function CResult_ErrorMessageDecodeErrorZ_get_ok(owner: number): number {
5226 if(!isWasmInitialized) {
5227 throw new Error("initializeWasm() must be awaited first!");
5229 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_ok(owner);
5230 return nativeResponseValue;
5232 // struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner);
5234 export function CResult_ErrorMessageDecodeErrorZ_get_err(owner: number): number {
5235 if(!isWasmInitialized) {
5236 throw new Error("initializeWasm() must be awaited first!");
5238 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_get_err(owner);
5239 return nativeResponseValue;
5241 // struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5243 export function CResult_WarningMessageDecodeErrorZ_get_ok(owner: number): number {
5244 if(!isWasmInitialized) {
5245 throw new Error("initializeWasm() must be awaited first!");
5247 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_ok(owner);
5248 return nativeResponseValue;
5250 // struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner);
5252 export function CResult_WarningMessageDecodeErrorZ_get_err(owner: number): number {
5253 if(!isWasmInitialized) {
5254 throw new Error("initializeWasm() must be awaited first!");
5256 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_get_err(owner);
5257 return nativeResponseValue;
5259 // struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5261 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5262 if(!isWasmInitialized) {
5263 throw new Error("initializeWasm() must be awaited first!");
5265 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner);
5266 return nativeResponseValue;
5268 // struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5270 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5271 if(!isWasmInitialized) {
5272 throw new Error("initializeWasm() must be awaited first!");
5274 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner);
5275 return nativeResponseValue;
5277 // struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5279 export function CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner: number): number {
5280 if(!isWasmInitialized) {
5281 throw new Error("initializeWasm() must be awaited first!");
5283 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner);
5284 return nativeResponseValue;
5286 // struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner);
5288 export function CResult_NodeAnnouncementDecodeErrorZ_get_err(owner: number): number {
5289 if(!isWasmInitialized) {
5290 throw new Error("initializeWasm() must be awaited first!");
5292 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(owner);
5293 return nativeResponseValue;
5295 // struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5297 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner: number): number {
5298 if(!isWasmInitialized) {
5299 throw new Error("initializeWasm() must be awaited first!");
5301 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner);
5302 return nativeResponseValue;
5304 // struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner);
5306 export function CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner: number): number {
5307 if(!isWasmInitialized) {
5308 throw new Error("initializeWasm() must be awaited first!");
5310 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner);
5311 return nativeResponseValue;
5313 // struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5315 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner: number): number {
5316 if(!isWasmInitialized) {
5317 throw new Error("initializeWasm() must be awaited first!");
5319 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner);
5320 return nativeResponseValue;
5322 // struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner);
5324 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner: number): number {
5325 if(!isWasmInitialized) {
5326 throw new Error("initializeWasm() must be awaited first!");
5328 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner);
5329 return nativeResponseValue;
5331 // struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5333 export function CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5334 if(!isWasmInitialized) {
5335 throw new Error("initializeWasm() must be awaited first!");
5337 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner);
5338 return nativeResponseValue;
5340 // struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5342 export function CResult_QueryChannelRangeDecodeErrorZ_get_err(owner: number): number {
5343 if(!isWasmInitialized) {
5344 throw new Error("initializeWasm() must be awaited first!");
5346 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(owner);
5347 return nativeResponseValue;
5349 // struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5351 export function CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner: number): number {
5352 if(!isWasmInitialized) {
5353 throw new Error("initializeWasm() must be awaited first!");
5355 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner);
5356 return nativeResponseValue;
5358 // struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner);
5360 export function CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner: number): number {
5361 if(!isWasmInitialized) {
5362 throw new Error("initializeWasm() must be awaited first!");
5364 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner);
5365 return nativeResponseValue;
5367 // struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5369 export function CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner: number): number {
5370 if(!isWasmInitialized) {
5371 throw new Error("initializeWasm() must be awaited first!");
5373 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner);
5374 return nativeResponseValue;
5376 // struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner);
5378 export function CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner: number): number {
5379 if(!isWasmInitialized) {
5380 throw new Error("initializeWasm() must be awaited first!");
5382 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner);
5383 return nativeResponseValue;
5386 export class LDKSignOrCreationError {
5387 protected constructor() {}
5390 export function LDKSignOrCreationError_ty_from_ptr(ptr: number): number {
5391 if(!isWasmInitialized) {
5392 throw new Error("initializeWasm() must be awaited first!");
5394 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_ty_from_ptr(ptr);
5395 return nativeResponseValue;
5398 export function LDKSignOrCreationError_CreationError_get_creation_error(ptr: number): CreationError {
5399 if(!isWasmInitialized) {
5400 throw new Error("initializeWasm() must be awaited first!");
5402 const nativeResponseValue = wasm.TS_LDKSignOrCreationError_CreationError_get_creation_error(ptr);
5403 return nativeResponseValue;
5405 // struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5407 export function CResult_InvoiceSignOrCreationErrorZ_get_ok(owner: number): number {
5408 if(!isWasmInitialized) {
5409 throw new Error("initializeWasm() must be awaited first!");
5411 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(owner);
5412 return nativeResponseValue;
5414 // struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner);
5416 export function CResult_InvoiceSignOrCreationErrorZ_get_err(owner: number): number {
5417 if(!isWasmInitialized) {
5418 throw new Error("initializeWasm() must be awaited first!");
5420 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_get_err(owner);
5421 return nativeResponseValue;
5424 export interface LDKFilter {
5425 register_tx (txid: number, script_pubkey: number): void;
5426 register_output (output: number): number;
5430 export function LDKFilter_new(impl: LDKFilter): number {
5431 if(!isWasmInitialized) {
5432 throw new Error("initializeWasm() must be awaited first!");
5434 var new_obj_idx = js_objs.length;
5435 for (var i = 0; i < js_objs.length; i++) {
5436 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5438 js_objs[i] = new WeakRef(impl);
5439 return wasm.TS_LDKFilter_new(i);
5441 // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
5443 export function Filter_register_tx(this_arg: number, txid: number, script_pubkey: number): void {
5444 if(!isWasmInitialized) {
5445 throw new Error("initializeWasm() must be awaited first!");
5447 const nativeResponseValue = wasm.TS_Filter_register_tx(this_arg, txid, script_pubkey);
5448 // debug statements here
5450 // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
5452 export function Filter_register_output(this_arg: number, output: number): number {
5453 if(!isWasmInitialized) {
5454 throw new Error("initializeWasm() must be awaited first!");
5456 const nativeResponseValue = wasm.TS_Filter_register_output(this_arg, output);
5457 return nativeResponseValue;
5460 export class LDKCOption_FilterZ {
5461 protected constructor() {}
5464 export function LDKCOption_FilterZ_ty_from_ptr(ptr: number): number {
5465 if(!isWasmInitialized) {
5466 throw new Error("initializeWasm() must be awaited first!");
5468 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_ty_from_ptr(ptr);
5469 return nativeResponseValue;
5472 export function LDKCOption_FilterZ_Some_get_some(ptr: number): number {
5473 if(!isWasmInitialized) {
5474 throw new Error("initializeWasm() must be awaited first!");
5476 const nativeResponseValue = wasm.TS_LDKCOption_FilterZ_Some_get_some(ptr);
5477 return nativeResponseValue;
5479 // struct LDKLockedChannelMonitor *CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5481 export function CResult_LockedChannelMonitorNoneZ_get_ok(owner: number): number {
5482 if(!isWasmInitialized) {
5483 throw new Error("initializeWasm() must be awaited first!");
5485 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_ok(owner);
5486 return nativeResponseValue;
5488 // void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner);
5490 export function CResult_LockedChannelMonitorNoneZ_get_err(owner: number): void {
5491 if(!isWasmInitialized) {
5492 throw new Error("initializeWasm() must be awaited first!");
5494 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_get_err(owner);
5495 // debug statements here
5498 export interface LDKMessageSendEventsProvider {
5499 get_and_clear_pending_msg_events (): number;
5503 export function LDKMessageSendEventsProvider_new(impl: LDKMessageSendEventsProvider): number {
5504 if(!isWasmInitialized) {
5505 throw new Error("initializeWasm() must be awaited first!");
5507 var new_obj_idx = js_objs.length;
5508 for (var i = 0; i < js_objs.length; i++) {
5509 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5511 js_objs[i] = new WeakRef(impl);
5512 return wasm.TS_LDKMessageSendEventsProvider_new(i);
5514 // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
5516 export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: number): number {
5517 if(!isWasmInitialized) {
5518 throw new Error("initializeWasm() must be awaited first!");
5520 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg);
5521 return nativeResponseValue;
5524 export interface LDKEventHandler {
5525 handle_event (event: number): void;
5529 export function LDKEventHandler_new(impl: LDKEventHandler): number {
5530 if(!isWasmInitialized) {
5531 throw new Error("initializeWasm() must be awaited first!");
5533 var new_obj_idx = js_objs.length;
5534 for (var i = 0; i < js_objs.length; i++) {
5535 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5537 js_objs[i] = new WeakRef(impl);
5538 return wasm.TS_LDKEventHandler_new(i);
5540 // void EventHandler_handle_event LDKEventHandler *NONNULL_PTR this_arg, const struct LDKEvent *NONNULL_PTR event
5542 export function EventHandler_handle_event(this_arg: number, event: number): void {
5543 if(!isWasmInitialized) {
5544 throw new Error("initializeWasm() must be awaited first!");
5546 const nativeResponseValue = wasm.TS_EventHandler_handle_event(this_arg, event);
5547 // debug statements here
5550 export interface LDKEventsProvider {
5551 process_pending_events (handler: number): void;
5555 export function LDKEventsProvider_new(impl: LDKEventsProvider): number {
5556 if(!isWasmInitialized) {
5557 throw new Error("initializeWasm() must be awaited first!");
5559 var new_obj_idx = js_objs.length;
5560 for (var i = 0; i < js_objs.length; i++) {
5561 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5563 js_objs[i] = new WeakRef(impl);
5564 return wasm.TS_LDKEventsProvider_new(i);
5566 // void EventsProvider_process_pending_events LDKEventsProvider *NONNULL_PTR this_arg, struct LDKEventHandler handler
5568 export function EventsProvider_process_pending_events(this_arg: number, handler: number): void {
5569 if(!isWasmInitialized) {
5570 throw new Error("initializeWasm() must be awaited first!");
5572 const nativeResponseValue = wasm.TS_EventsProvider_process_pending_events(this_arg, handler);
5573 // debug statements here
5576 export interface LDKScore {
5577 channel_penalty_msat (short_channel_id: bigint, source: number, target: number, usage: number): bigint;
5578 payment_path_failed (path: number, short_channel_id: bigint): void;
5579 payment_path_successful (path: number): void;
5584 export function LDKScore_new(impl: LDKScore): number {
5585 if(!isWasmInitialized) {
5586 throw new Error("initializeWasm() must be awaited first!");
5588 var new_obj_idx = js_objs.length;
5589 for (var i = 0; i < js_objs.length; i++) {
5590 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5592 js_objs[i] = new WeakRef(impl);
5593 return wasm.TS_LDKScore_new(i);
5595 // 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
5597 export function Score_channel_penalty_msat(this_arg: number, short_channel_id: bigint, source: number, target: number, usage: number): bigint {
5598 if(!isWasmInitialized) {
5599 throw new Error("initializeWasm() must be awaited first!");
5601 const nativeResponseValue = wasm.TS_Score_channel_penalty_msat(this_arg, short_channel_id, source, target, usage);
5602 return nativeResponseValue;
5604 // void Score_payment_path_failed LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path, uint64_t short_channel_id
5606 export function Score_payment_path_failed(this_arg: number, path: number, short_channel_id: bigint): void {
5607 if(!isWasmInitialized) {
5608 throw new Error("initializeWasm() must be awaited first!");
5610 const nativeResponseValue = wasm.TS_Score_payment_path_failed(this_arg, path, short_channel_id);
5611 // debug statements here
5613 // void Score_payment_path_successful LDKScore *NONNULL_PTR this_arg, struct LDKCVec_RouteHopZ path
5615 export function Score_payment_path_successful(this_arg: number, path: number): void {
5616 if(!isWasmInitialized) {
5617 throw new Error("initializeWasm() must be awaited first!");
5619 const nativeResponseValue = wasm.TS_Score_payment_path_successful(this_arg, path);
5620 // debug statements here
5622 // LDKCVec_u8Z Score_write LDKScore *NONNULL_PTR this_arg
5624 export function Score_write(this_arg: number): number {
5625 if(!isWasmInitialized) {
5626 throw new Error("initializeWasm() must be awaited first!");
5628 const nativeResponseValue = wasm.TS_Score_write(this_arg);
5629 return nativeResponseValue;
5632 export interface LDKPersister {
5633 persist_manager (channel_manager: number): number;
5634 persist_graph (network_graph: number): number;
5635 persist_scorer (scorer: number): number;
5639 export function LDKPersister_new(impl: LDKPersister): number {
5640 if(!isWasmInitialized) {
5641 throw new Error("initializeWasm() must be awaited first!");
5643 var new_obj_idx = js_objs.length;
5644 for (var i = 0; i < js_objs.length; i++) {
5645 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5647 js_objs[i] = new WeakRef(impl);
5648 return wasm.TS_LDKPersister_new(i);
5650 // LDKCResult_NoneErrorZ Persister_persist_manager LDKPersister *NONNULL_PTR this_arg, const struct LDKChannelManager *NONNULL_PTR channel_manager
5652 export function Persister_persist_manager(this_arg: number, channel_manager: number): number {
5653 if(!isWasmInitialized) {
5654 throw new Error("initializeWasm() must be awaited first!");
5656 const nativeResponseValue = wasm.TS_Persister_persist_manager(this_arg, channel_manager);
5657 return nativeResponseValue;
5659 // LDKCResult_NoneErrorZ Persister_persist_graph LDKPersister *NONNULL_PTR this_arg, const struct LDKNetworkGraph *NONNULL_PTR network_graph
5661 export function Persister_persist_graph(this_arg: number, network_graph: number): number {
5662 if(!isWasmInitialized) {
5663 throw new Error("initializeWasm() must be awaited first!");
5665 const nativeResponseValue = wasm.TS_Persister_persist_graph(this_arg, network_graph);
5666 return nativeResponseValue;
5668 // LDKCResult_NoneErrorZ Persister_persist_scorer LDKPersister *NONNULL_PTR this_arg, const struct LDKMultiThreadedLockableScore *NONNULL_PTR scorer
5670 export function Persister_persist_scorer(this_arg: number, scorer: number): number {
5671 if(!isWasmInitialized) {
5672 throw new Error("initializeWasm() must be awaited first!");
5674 const nativeResponseValue = wasm.TS_Persister_persist_scorer(this_arg, scorer);
5675 return nativeResponseValue;
5678 export interface LDKListen {
5679 filtered_block_connected (header: number, txdata: number, height: number): void;
5680 block_connected (block: number, height: number): void;
5681 block_disconnected (header: number, height: number): void;
5685 export function LDKListen_new(impl: LDKListen): number {
5686 if(!isWasmInitialized) {
5687 throw new Error("initializeWasm() must be awaited first!");
5689 var new_obj_idx = js_objs.length;
5690 for (var i = 0; i < js_objs.length; i++) {
5691 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5693 js_objs[i] = new WeakRef(impl);
5694 return wasm.TS_LDKListen_new(i);
5696 // void Listen_filtered_block_connected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5698 export function Listen_filtered_block_connected(this_arg: number, header: number, txdata: number, height: number): void {
5699 if(!isWasmInitialized) {
5700 throw new Error("initializeWasm() must be awaited first!");
5702 const nativeResponseValue = wasm.TS_Listen_filtered_block_connected(this_arg, header, txdata, height);
5703 // debug statements here
5705 // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
5707 export function Listen_block_connected(this_arg: number, block: number, height: number): void {
5708 if(!isWasmInitialized) {
5709 throw new Error("initializeWasm() must be awaited first!");
5711 const nativeResponseValue = wasm.TS_Listen_block_connected(this_arg, block, height);
5712 // debug statements here
5714 // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5716 export function Listen_block_disconnected(this_arg: number, header: number, height: number): void {
5717 if(!isWasmInitialized) {
5718 throw new Error("initializeWasm() must be awaited first!");
5720 const nativeResponseValue = wasm.TS_Listen_block_disconnected(this_arg, header, height);
5721 // debug statements here
5724 export interface LDKConfirm {
5725 transactions_confirmed (header: number, txdata: number, height: number): void;
5726 transaction_unconfirmed (txid: number): void;
5727 best_block_updated (header: number, height: number): void;
5728 get_relevant_txids (): number;
5732 export function LDKConfirm_new(impl: LDKConfirm): number {
5733 if(!isWasmInitialized) {
5734 throw new Error("initializeWasm() must be awaited first!");
5736 var new_obj_idx = js_objs.length;
5737 for (var i = 0; i < js_objs.length; i++) {
5738 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5740 js_objs[i] = new WeakRef(impl);
5741 return wasm.TS_LDKConfirm_new(i);
5743 // void Confirm_transactions_confirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height
5745 export function Confirm_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number): void {
5746 if(!isWasmInitialized) {
5747 throw new Error("initializeWasm() must be awaited first!");
5749 const nativeResponseValue = wasm.TS_Confirm_transactions_confirmed(this_arg, header, txdata, height);
5750 // debug statements here
5752 // void Confirm_transaction_unconfirmed LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*txid)[32]
5754 export function Confirm_transaction_unconfirmed(this_arg: number, txid: number): void {
5755 if(!isWasmInitialized) {
5756 throw new Error("initializeWasm() must be awaited first!");
5758 const nativeResponseValue = wasm.TS_Confirm_transaction_unconfirmed(this_arg, txid);
5759 // debug statements here
5761 // void Confirm_best_block_updated LDKConfirm *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
5763 export function Confirm_best_block_updated(this_arg: number, header: number, height: number): void {
5764 if(!isWasmInitialized) {
5765 throw new Error("initializeWasm() must be awaited first!");
5767 const nativeResponseValue = wasm.TS_Confirm_best_block_updated(this_arg, header, height);
5768 // debug statements here
5770 // LDKCVec_TxidZ Confirm_get_relevant_txids LDKConfirm *NONNULL_PTR this_arg
5772 export function Confirm_get_relevant_txids(this_arg: number): number {
5773 if(!isWasmInitialized) {
5774 throw new Error("initializeWasm() must be awaited first!");
5776 const nativeResponseValue = wasm.TS_Confirm_get_relevant_txids(this_arg);
5777 return nativeResponseValue;
5780 export interface LDKPersist {
5781 persist_new_channel (channel_id: number, data: number, update_id: number): number;
5782 update_persisted_channel (channel_id: number, update: number, data: number, update_id: number): number;
5786 export function LDKPersist_new(impl: LDKPersist): number {
5787 if(!isWasmInitialized) {
5788 throw new Error("initializeWasm() must be awaited first!");
5790 var new_obj_idx = js_objs.length;
5791 for (var i = 0; i < js_objs.length; i++) {
5792 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5794 js_objs[i] = new WeakRef(impl);
5795 return wasm.TS_LDKPersist_new(i);
5797 // 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
5799 export function Persist_persist_new_channel(this_arg: number, channel_id: number, data: number, update_id: number): number {
5800 if(!isWasmInitialized) {
5801 throw new Error("initializeWasm() must be awaited first!");
5803 const nativeResponseValue = wasm.TS_Persist_persist_new_channel(this_arg, channel_id, data, update_id);
5804 return nativeResponseValue;
5806 // 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
5808 export function Persist_update_persisted_channel(this_arg: number, channel_id: number, update: number, data: number, update_id: number): number {
5809 if(!isWasmInitialized) {
5810 throw new Error("initializeWasm() must be awaited first!");
5812 const nativeResponseValue = wasm.TS_Persist_update_persisted_channel(this_arg, channel_id, update, data, update_id);
5813 return nativeResponseValue;
5816 export interface LDKChannelMessageHandler {
5817 handle_open_channel (their_node_id: number, their_features: number, msg: number): void;
5818 handle_accept_channel (their_node_id: number, their_features: number, msg: number): void;
5819 handle_funding_created (their_node_id: number, msg: number): void;
5820 handle_funding_signed (their_node_id: number, msg: number): void;
5821 handle_channel_ready (their_node_id: number, msg: number): void;
5822 handle_shutdown (their_node_id: number, their_features: number, msg: number): void;
5823 handle_closing_signed (their_node_id: number, msg: number): void;
5824 handle_update_add_htlc (their_node_id: number, msg: number): void;
5825 handle_update_fulfill_htlc (their_node_id: number, msg: number): void;
5826 handle_update_fail_htlc (their_node_id: number, msg: number): void;
5827 handle_update_fail_malformed_htlc (their_node_id: number, msg: number): void;
5828 handle_commitment_signed (their_node_id: number, msg: number): void;
5829 handle_revoke_and_ack (their_node_id: number, msg: number): void;
5830 handle_update_fee (their_node_id: number, msg: number): void;
5831 handle_announcement_signatures (their_node_id: number, msg: number): void;
5832 peer_disconnected (their_node_id: number, no_connection_possible: boolean): void;
5833 peer_connected (their_node_id: number, msg: number): void;
5834 handle_channel_reestablish (their_node_id: number, msg: number): void;
5835 handle_channel_update (their_node_id: number, msg: number): void;
5836 handle_error (their_node_id: number, msg: number): void;
5840 export function LDKChannelMessageHandler_new(impl: LDKChannelMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
5841 if(!isWasmInitialized) {
5842 throw new Error("initializeWasm() must be awaited first!");
5844 var new_obj_idx = js_objs.length;
5845 for (var i = 0; i < js_objs.length; i++) {
5846 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
5848 js_objs[i] = new WeakRef(impl);
5849 return wasm.TS_LDKChannelMessageHandler_new(i);
5851 // 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
5853 export function ChannelMessageHandler_handle_open_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5854 if(!isWasmInitialized) {
5855 throw new Error("initializeWasm() must be awaited first!");
5857 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_open_channel(this_arg, their_node_id, their_features, msg);
5858 // debug statements here
5860 // 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
5862 export function ChannelMessageHandler_handle_accept_channel(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5863 if(!isWasmInitialized) {
5864 throw new Error("initializeWasm() must be awaited first!");
5866 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_accept_channel(this_arg, their_node_id, their_features, msg);
5867 // debug statements here
5869 // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
5871 export function ChannelMessageHandler_handle_funding_created(this_arg: number, their_node_id: number, msg: number): void {
5872 if(!isWasmInitialized) {
5873 throw new Error("initializeWasm() must be awaited first!");
5875 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_created(this_arg, their_node_id, msg);
5876 // debug statements here
5878 // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
5880 export function ChannelMessageHandler_handle_funding_signed(this_arg: number, their_node_id: number, msg: number): void {
5881 if(!isWasmInitialized) {
5882 throw new Error("initializeWasm() must be awaited first!");
5884 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_funding_signed(this_arg, their_node_id, msg);
5885 // debug statements here
5887 // void ChannelMessageHandler_handle_channel_ready LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReady *NONNULL_PTR msg
5889 export function ChannelMessageHandler_handle_channel_ready(this_arg: number, their_node_id: number, msg: number): void {
5890 if(!isWasmInitialized) {
5891 throw new Error("initializeWasm() must be awaited first!");
5893 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_ready(this_arg, their_node_id, msg);
5894 // debug statements here
5896 // 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
5898 export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: number, their_features: number, msg: number): void {
5899 if(!isWasmInitialized) {
5900 throw new Error("initializeWasm() must be awaited first!");
5902 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_shutdown(this_arg, their_node_id, their_features, msg);
5903 // debug statements here
5905 // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
5907 export function ChannelMessageHandler_handle_closing_signed(this_arg: number, their_node_id: number, msg: number): void {
5908 if(!isWasmInitialized) {
5909 throw new Error("initializeWasm() must be awaited first!");
5911 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_closing_signed(this_arg, their_node_id, msg);
5912 // debug statements here
5914 // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
5916 export function ChannelMessageHandler_handle_update_add_htlc(this_arg: number, their_node_id: number, msg: number): void {
5917 if(!isWasmInitialized) {
5918 throw new Error("initializeWasm() must be awaited first!");
5920 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_add_htlc(this_arg, their_node_id, msg);
5921 // debug statements here
5923 // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
5925 export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: number, their_node_id: number, msg: number): void {
5926 if(!isWasmInitialized) {
5927 throw new Error("initializeWasm() must be awaited first!");
5929 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, their_node_id, msg);
5930 // debug statements here
5932 // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
5934 export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: number, their_node_id: number, msg: number): void {
5935 if(!isWasmInitialized) {
5936 throw new Error("initializeWasm() must be awaited first!");
5938 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_htlc(this_arg, their_node_id, msg);
5939 // debug statements here
5941 // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
5943 export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: number, their_node_id: number, msg: number): void {
5944 if(!isWasmInitialized) {
5945 throw new Error("initializeWasm() must be awaited first!");
5947 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, their_node_id, msg);
5948 // debug statements here
5950 // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
5952 export function ChannelMessageHandler_handle_commitment_signed(this_arg: number, their_node_id: number, msg: number): void {
5953 if(!isWasmInitialized) {
5954 throw new Error("initializeWasm() must be awaited first!");
5956 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_commitment_signed(this_arg, their_node_id, msg);
5957 // debug statements here
5959 // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
5961 export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: number, their_node_id: number, msg: number): void {
5962 if(!isWasmInitialized) {
5963 throw new Error("initializeWasm() must be awaited first!");
5965 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_revoke_and_ack(this_arg, their_node_id, msg);
5966 // debug statements here
5968 // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
5970 export function ChannelMessageHandler_handle_update_fee(this_arg: number, their_node_id: number, msg: number): void {
5971 if(!isWasmInitialized) {
5972 throw new Error("initializeWasm() must be awaited first!");
5974 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_update_fee(this_arg, their_node_id, msg);
5975 // debug statements here
5977 // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
5979 export function ChannelMessageHandler_handle_announcement_signatures(this_arg: number, their_node_id: number, msg: number): void {
5980 if(!isWasmInitialized) {
5981 throw new Error("initializeWasm() must be awaited first!");
5983 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_announcement_signatures(this_arg, their_node_id, msg);
5984 // debug statements here
5986 // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
5988 export function ChannelMessageHandler_peer_disconnected(this_arg: number, their_node_id: number, no_connection_possible: boolean): void {
5989 if(!isWasmInitialized) {
5990 throw new Error("initializeWasm() must be awaited first!");
5992 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_disconnected(this_arg, their_node_id, no_connection_possible);
5993 // debug statements here
5995 // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
5997 export function ChannelMessageHandler_peer_connected(this_arg: number, their_node_id: number, msg: number): void {
5998 if(!isWasmInitialized) {
5999 throw new Error("initializeWasm() must be awaited first!");
6001 const nativeResponseValue = wasm.TS_ChannelMessageHandler_peer_connected(this_arg, their_node_id, msg);
6002 // debug statements here
6004 // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
6006 export function ChannelMessageHandler_handle_channel_reestablish(this_arg: number, their_node_id: number, msg: number): void {
6007 if(!isWasmInitialized) {
6008 throw new Error("initializeWasm() must be awaited first!");
6010 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_reestablish(this_arg, their_node_id, msg);
6011 // debug statements here
6013 // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
6015 export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: number, msg: number): void {
6016 if(!isWasmInitialized) {
6017 throw new Error("initializeWasm() must be awaited first!");
6019 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_channel_update(this_arg, their_node_id, msg);
6020 // debug statements here
6022 // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
6024 export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: number, msg: number): void {
6025 if(!isWasmInitialized) {
6026 throw new Error("initializeWasm() must be awaited first!");
6028 const nativeResponseValue = wasm.TS_ChannelMessageHandler_handle_error(this_arg, their_node_id, msg);
6029 // debug statements here
6032 export interface LDKRoutingMessageHandler {
6033 handle_node_announcement (msg: number): number;
6034 handle_channel_announcement (msg: number): number;
6035 handle_channel_update (msg: number): number;
6036 get_next_channel_announcements (starting_point: bigint, batch_amount: number): number;
6037 get_next_node_announcements (starting_point: number, batch_amount: number): number;
6038 peer_connected (their_node_id: number, init: number): void;
6039 handle_reply_channel_range (their_node_id: number, msg: number): number;
6040 handle_reply_short_channel_ids_end (their_node_id: number, msg: number): number;
6041 handle_query_channel_range (their_node_id: number, msg: number): number;
6042 handle_query_short_channel_ids (their_node_id: number, msg: number): number;
6046 export function LDKRoutingMessageHandler_new(impl: LDKRoutingMessageHandler, MessageSendEventsProvider: LDKMessageSendEventsProvider): number {
6047 if(!isWasmInitialized) {
6048 throw new Error("initializeWasm() must be awaited first!");
6050 var new_obj_idx = js_objs.length;
6051 for (var i = 0; i < js_objs.length; i++) {
6052 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6054 js_objs[i] = new WeakRef(impl);
6055 return wasm.TS_LDKRoutingMessageHandler_new(i);
6057 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
6059 export function RoutingMessageHandler_handle_node_announcement(this_arg: number, msg: number): number {
6060 if(!isWasmInitialized) {
6061 throw new Error("initializeWasm() must be awaited first!");
6063 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_node_announcement(this_arg, msg);
6064 return nativeResponseValue;
6066 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
6068 export function RoutingMessageHandler_handle_channel_announcement(this_arg: number, msg: number): number {
6069 if(!isWasmInitialized) {
6070 throw new Error("initializeWasm() must be awaited first!");
6072 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
6073 return nativeResponseValue;
6075 // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
6077 export function RoutingMessageHandler_handle_channel_update(this_arg: number, msg: number): number {
6078 if(!isWasmInitialized) {
6079 throw new Error("initializeWasm() must be awaited first!");
6081 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_channel_update(this_arg, msg);
6082 return nativeResponseValue;
6084 // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
6086 export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: bigint, batch_amount: number): number {
6087 if(!isWasmInitialized) {
6088 throw new Error("initializeWasm() must be awaited first!");
6090 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
6091 return nativeResponseValue;
6093 // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
6095 export function RoutingMessageHandler_get_next_node_announcements(this_arg: number, starting_point: number, batch_amount: number): number {
6096 if(!isWasmInitialized) {
6097 throw new Error("initializeWasm() must be awaited first!");
6099 const nativeResponseValue = wasm.TS_RoutingMessageHandler_get_next_node_announcements(this_arg, starting_point, batch_amount);
6100 return nativeResponseValue;
6102 // void RoutingMessageHandler_peer_connected LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
6104 export function RoutingMessageHandler_peer_connected(this_arg: number, their_node_id: number, init: number): void {
6105 if(!isWasmInitialized) {
6106 throw new Error("initializeWasm() must be awaited first!");
6108 const nativeResponseValue = wasm.TS_RoutingMessageHandler_peer_connected(this_arg, their_node_id, init);
6109 // debug statements here
6111 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
6113 export function RoutingMessageHandler_handle_reply_channel_range(this_arg: number, their_node_id: number, msg: number): number {
6114 if(!isWasmInitialized) {
6115 throw new Error("initializeWasm() must be awaited first!");
6117 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_channel_range(this_arg, their_node_id, msg);
6118 return nativeResponseValue;
6120 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
6122 export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: number, their_node_id: number, msg: number): number {
6123 if(!isWasmInitialized) {
6124 throw new Error("initializeWasm() must be awaited first!");
6126 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, their_node_id, msg);
6127 return nativeResponseValue;
6129 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
6131 export function RoutingMessageHandler_handle_query_channel_range(this_arg: number, their_node_id: number, msg: number): number {
6132 if(!isWasmInitialized) {
6133 throw new Error("initializeWasm() must be awaited first!");
6135 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_channel_range(this_arg, their_node_id, msg);
6136 return nativeResponseValue;
6138 // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
6140 export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: number, their_node_id: number, msg: number): number {
6141 if(!isWasmInitialized) {
6142 throw new Error("initializeWasm() must be awaited first!");
6144 const nativeResponseValue = wasm.TS_RoutingMessageHandler_handle_query_short_channel_ids(this_arg, their_node_id, msg);
6145 return nativeResponseValue;
6148 export interface LDKCustomMessageReader {
6149 read (message_type: number, buffer: number): number;
6153 export function LDKCustomMessageReader_new(impl: LDKCustomMessageReader): number {
6154 if(!isWasmInitialized) {
6155 throw new Error("initializeWasm() must be awaited first!");
6157 var new_obj_idx = js_objs.length;
6158 for (var i = 0; i < js_objs.length; i++) {
6159 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6161 js_objs[i] = new WeakRef(impl);
6162 return wasm.TS_LDKCustomMessageReader_new(i);
6164 // LDKCResult_COption_TypeZDecodeErrorZ CustomMessageReader_read LDKCustomMessageReader *NONNULL_PTR this_arg, uint16_t message_type, struct LDKu8slice buffer
6166 export function CustomMessageReader_read(this_arg: number, message_type: number, buffer: number): number {
6167 if(!isWasmInitialized) {
6168 throw new Error("initializeWasm() must be awaited first!");
6170 const nativeResponseValue = wasm.TS_CustomMessageReader_read(this_arg, message_type, buffer);
6171 return nativeResponseValue;
6174 export interface LDKCustomMessageHandler {
6175 handle_custom_message (msg: number, sender_node_id: number): number;
6176 get_and_clear_pending_msg (): number;
6180 export function LDKCustomMessageHandler_new(impl: LDKCustomMessageHandler, CustomMessageReader: LDKCustomMessageReader): number {
6181 if(!isWasmInitialized) {
6182 throw new Error("initializeWasm() must be awaited first!");
6184 var new_obj_idx = js_objs.length;
6185 for (var i = 0; i < js_objs.length; i++) {
6186 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6188 js_objs[i] = new WeakRef(impl);
6189 return wasm.TS_LDKCustomMessageHandler_new(i);
6191 // LDKCResult_NoneLightningErrorZ CustomMessageHandler_handle_custom_message LDKCustomMessageHandler *NONNULL_PTR this_arg, struct LDKType msg, struct LDKPublicKey sender_node_id
6193 export function CustomMessageHandler_handle_custom_message(this_arg: number, msg: number, sender_node_id: number): number {
6194 if(!isWasmInitialized) {
6195 throw new Error("initializeWasm() must be awaited first!");
6197 const nativeResponseValue = wasm.TS_CustomMessageHandler_handle_custom_message(this_arg, msg, sender_node_id);
6198 return nativeResponseValue;
6200 // LDKCVec_C2Tuple_PublicKeyTypeZZ CustomMessageHandler_get_and_clear_pending_msg LDKCustomMessageHandler *NONNULL_PTR this_arg
6202 export function CustomMessageHandler_get_and_clear_pending_msg(this_arg: number): number {
6203 if(!isWasmInitialized) {
6204 throw new Error("initializeWasm() must be awaited first!");
6206 const nativeResponseValue = wasm.TS_CustomMessageHandler_get_and_clear_pending_msg(this_arg);
6207 return nativeResponseValue;
6210 export interface LDKSocketDescriptor {
6211 send_data (data: number, resume_read: boolean): number;
6212 disconnect_socket (): void;
6213 eq (other_arg: number): boolean;
6218 export function LDKSocketDescriptor_new(impl: LDKSocketDescriptor): number {
6219 if(!isWasmInitialized) {
6220 throw new Error("initializeWasm() must be awaited first!");
6222 var new_obj_idx = js_objs.length;
6223 for (var i = 0; i < js_objs.length; i++) {
6224 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6226 js_objs[i] = new WeakRef(impl);
6227 return wasm.TS_LDKSocketDescriptor_new(i);
6229 // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
6231 export function SocketDescriptor_send_data(this_arg: number, data: number, resume_read: boolean): number {
6232 if(!isWasmInitialized) {
6233 throw new Error("initializeWasm() must be awaited first!");
6235 const nativeResponseValue = wasm.TS_SocketDescriptor_send_data(this_arg, data, resume_read);
6236 return nativeResponseValue;
6238 // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
6240 export function SocketDescriptor_disconnect_socket(this_arg: number): void {
6241 if(!isWasmInitialized) {
6242 throw new Error("initializeWasm() must be awaited first!");
6244 const nativeResponseValue = wasm.TS_SocketDescriptor_disconnect_socket(this_arg);
6245 // debug statements here
6247 // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
6249 export function SocketDescriptor_hash(this_arg: number): bigint {
6250 if(!isWasmInitialized) {
6251 throw new Error("initializeWasm() must be awaited first!");
6253 const nativeResponseValue = wasm.TS_SocketDescriptor_hash(this_arg);
6254 return nativeResponseValue;
6257 export class LDKEffectiveCapacity {
6258 protected constructor() {}
6261 export function LDKEffectiveCapacity_ty_from_ptr(ptr: number): number {
6262 if(!isWasmInitialized) {
6263 throw new Error("initializeWasm() must be awaited first!");
6265 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ty_from_ptr(ptr);
6266 return nativeResponseValue;
6269 export function LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr: number): bigint {
6270 if(!isWasmInitialized) {
6271 throw new Error("initializeWasm() must be awaited first!");
6273 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(ptr);
6274 return nativeResponseValue;
6277 export function LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr: number): bigint {
6278 if(!isWasmInitialized) {
6279 throw new Error("initializeWasm() must be awaited first!");
6281 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(ptr);
6282 return nativeResponseValue;
6285 export function LDKEffectiveCapacity_Total_get_capacity_msat(ptr: number): bigint {
6286 if(!isWasmInitialized) {
6287 throw new Error("initializeWasm() must be awaited first!");
6289 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_capacity_msat(ptr);
6290 return nativeResponseValue;
6293 export function LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr: number): number {
6294 if(!isWasmInitialized) {
6295 throw new Error("initializeWasm() must be awaited first!");
6297 const nativeResponseValue = wasm.TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(ptr);
6298 return nativeResponseValue;
6301 export interface LDKLockableScore {
6306 export function LDKLockableScore_new(impl: LDKLockableScore): number {
6307 if(!isWasmInitialized) {
6308 throw new Error("initializeWasm() must be awaited first!");
6310 var new_obj_idx = js_objs.length;
6311 for (var i = 0; i < js_objs.length; i++) {
6312 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6314 js_objs[i] = new WeakRef(impl);
6315 return wasm.TS_LDKLockableScore_new(i);
6317 // LDKScore LockableScore_lock LDKLockableScore *NONNULL_PTR this_arg
6319 export function LockableScore_lock(this_arg: number): number {
6320 if(!isWasmInitialized) {
6321 throw new Error("initializeWasm() must be awaited first!");
6323 const nativeResponseValue = wasm.TS_LockableScore_lock(this_arg);
6324 return nativeResponseValue;
6327 export class LDKFallback {
6328 protected constructor() {}
6331 export function LDKFallback_ty_from_ptr(ptr: number): number {
6332 if(!isWasmInitialized) {
6333 throw new Error("initializeWasm() must be awaited first!");
6335 const nativeResponseValue = wasm.TS_LDKFallback_ty_from_ptr(ptr);
6336 return nativeResponseValue;
6339 export function LDKFallback_SegWitProgram_get_version(ptr: number): number {
6340 if(!isWasmInitialized) {
6341 throw new Error("initializeWasm() must be awaited first!");
6343 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_version(ptr);
6344 return nativeResponseValue;
6347 export function LDKFallback_SegWitProgram_get_program(ptr: number): number {
6348 if(!isWasmInitialized) {
6349 throw new Error("initializeWasm() must be awaited first!");
6351 const nativeResponseValue = wasm.TS_LDKFallback_SegWitProgram_get_program(ptr);
6352 return nativeResponseValue;
6355 export function LDKFallback_PubKeyHash_get_pub_key_hash(ptr: number): number {
6356 if(!isWasmInitialized) {
6357 throw new Error("initializeWasm() must be awaited first!");
6359 const nativeResponseValue = wasm.TS_LDKFallback_PubKeyHash_get_pub_key_hash(ptr);
6360 return nativeResponseValue;
6363 export function LDKFallback_ScriptHash_get_script_hash(ptr: number): number {
6364 if(!isWasmInitialized) {
6365 throw new Error("initializeWasm() must be awaited first!");
6367 const nativeResponseValue = wasm.TS_LDKFallback_ScriptHash_get_script_hash(ptr);
6368 return nativeResponseValue;
6371 export interface LDKPayer {
6373 first_hops (): number;
6374 send_payment (route: number, payment_hash: number, payment_secret: number): number;
6375 send_spontaneous_payment (route: number, payment_preimage: number): number;
6376 retry_payment (route: number, payment_id: number): number;
6377 abandon_payment (payment_id: number): void;
6381 export function LDKPayer_new(impl: LDKPayer): number {
6382 if(!isWasmInitialized) {
6383 throw new Error("initializeWasm() must be awaited first!");
6385 var new_obj_idx = js_objs.length;
6386 for (var i = 0; i < js_objs.length; i++) {
6387 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6389 js_objs[i] = new WeakRef(impl);
6390 return wasm.TS_LDKPayer_new(i);
6392 // LDKPublicKey Payer_node_id LDKPayer *NONNULL_PTR this_arg
6394 export function Payer_node_id(this_arg: number): number {
6395 if(!isWasmInitialized) {
6396 throw new Error("initializeWasm() must be awaited first!");
6398 const nativeResponseValue = wasm.TS_Payer_node_id(this_arg);
6399 return nativeResponseValue;
6401 // LDKCVec_ChannelDetailsZ Payer_first_hops LDKPayer *NONNULL_PTR this_arg
6403 export function Payer_first_hops(this_arg: number): number {
6404 if(!isWasmInitialized) {
6405 throw new Error("initializeWasm() must be awaited first!");
6407 const nativeResponseValue = wasm.TS_Payer_first_hops(this_arg);
6408 return nativeResponseValue;
6410 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_hash, struct LDKThirtyTwoBytes payment_secret
6412 export function Payer_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
6413 if(!isWasmInitialized) {
6414 throw new Error("initializeWasm() must be awaited first!");
6416 const nativeResponseValue = wasm.TS_Payer_send_payment(this_arg, route, payment_hash, payment_secret);
6417 return nativeResponseValue;
6419 // LDKCResult_PaymentIdPaymentSendFailureZ Payer_send_spontaneous_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_preimage
6421 export function Payer_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
6422 if(!isWasmInitialized) {
6423 throw new Error("initializeWasm() must be awaited first!");
6425 const nativeResponseValue = wasm.TS_Payer_send_spontaneous_payment(this_arg, route, payment_preimage);
6426 return nativeResponseValue;
6428 // LDKCResult_NonePaymentSendFailureZ Payer_retry_payment LDKPayer *NONNULL_PTR this_arg, const struct LDKRoute *NONNULL_PTR route, struct LDKThirtyTwoBytes payment_id
6430 export function Payer_retry_payment(this_arg: number, route: number, payment_id: number): number {
6431 if(!isWasmInitialized) {
6432 throw new Error("initializeWasm() must be awaited first!");
6434 const nativeResponseValue = wasm.TS_Payer_retry_payment(this_arg, route, payment_id);
6435 return nativeResponseValue;
6437 // void Payer_abandon_payment LDKPayer *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id
6439 export function Payer_abandon_payment(this_arg: number, payment_id: number): void {
6440 if(!isWasmInitialized) {
6441 throw new Error("initializeWasm() must be awaited first!");
6443 const nativeResponseValue = wasm.TS_Payer_abandon_payment(this_arg, payment_id);
6444 // debug statements here
6447 export interface LDKRouter {
6448 find_route (payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number;
6452 export function LDKRouter_new(impl: LDKRouter): number {
6453 if(!isWasmInitialized) {
6454 throw new Error("initializeWasm() must be awaited first!");
6456 var new_obj_idx = js_objs.length;
6457 for (var i = 0; i < js_objs.length; i++) {
6458 if (js_objs[i] == null || js_objs[i] == undefined) { new_obj_idx = i; break; }
6460 js_objs[i] = new WeakRef(impl);
6461 return wasm.TS_LDKRouter_new(i);
6463 // 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
6465 export function Router_find_route(this_arg: number, payer: number, route_params: number, payment_hash: number, first_hops: number, scorer: number): number {
6466 if(!isWasmInitialized) {
6467 throw new Error("initializeWasm() must be awaited first!");
6469 const nativeResponseValue = wasm.TS_Router_find_route(this_arg, payer, route_params, payment_hash, first_hops, scorer);
6470 return nativeResponseValue;
6473 export class LDKRetry {
6474 protected constructor() {}
6477 export function LDKRetry_ty_from_ptr(ptr: number): number {
6478 if(!isWasmInitialized) {
6479 throw new Error("initializeWasm() must be awaited first!");
6481 const nativeResponseValue = wasm.TS_LDKRetry_ty_from_ptr(ptr);
6482 return nativeResponseValue;
6485 export function LDKRetry_Attempts_get_attempts(ptr: number): number {
6486 if(!isWasmInitialized) {
6487 throw new Error("initializeWasm() must be awaited first!");
6489 const nativeResponseValue = wasm.TS_LDKRetry_Attempts_get_attempts(ptr);
6490 return nativeResponseValue;
6492 // struct LDKStr _ldk_get_compiled_version(void);
6494 export function _ldk_get_compiled_version(): number {
6495 if(!isWasmInitialized) {
6496 throw new Error("initializeWasm() must be awaited first!");
6498 const nativeResponseValue = wasm.TS__ldk_get_compiled_version();
6499 return nativeResponseValue;
6501 // struct LDKStr _ldk_c_bindings_get_compiled_version(void);
6503 export function _ldk_c_bindings_get_compiled_version(): number {
6504 if(!isWasmInitialized) {
6505 throw new Error("initializeWasm() must be awaited first!");
6507 const nativeResponseValue = wasm.TS__ldk_c_bindings_get_compiled_version();
6508 return nativeResponseValue;
6510 // uintptr_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg);
6512 export function Bech32Error_clone_ptr(arg: number): number {
6513 if(!isWasmInitialized) {
6514 throw new Error("initializeWasm() must be awaited first!");
6516 const nativeResponseValue = wasm.TS_Bech32Error_clone_ptr(arg);
6517 return nativeResponseValue;
6519 // struct LDKBech32Error Bech32Error_clone(const struct LDKBech32Error *NONNULL_PTR orig);
6521 export function Bech32Error_clone(orig: number): number {
6522 if(!isWasmInitialized) {
6523 throw new Error("initializeWasm() must be awaited first!");
6525 const nativeResponseValue = wasm.TS_Bech32Error_clone(orig);
6526 return nativeResponseValue;
6528 // void Bech32Error_free(struct LDKBech32Error o);
6530 export function Bech32Error_free(o: number): void {
6531 if(!isWasmInitialized) {
6532 throw new Error("initializeWasm() must be awaited first!");
6534 const nativeResponseValue = wasm.TS_Bech32Error_free(o);
6535 // debug statements here
6537 // void Transaction_free(struct LDKTransaction _res);
6539 export function Transaction_free(_res: number): void {
6540 if(!isWasmInitialized) {
6541 throw new Error("initializeWasm() must be awaited first!");
6543 const nativeResponseValue = wasm.TS_Transaction_free(_res);
6544 // debug statements here
6546 // struct LDKTxOut TxOut_new(struct LDKCVec_u8Z script_pubkey, uint64_t value);
6548 export function TxOut_new(script_pubkey: number, value: bigint): number {
6549 if(!isWasmInitialized) {
6550 throw new Error("initializeWasm() must be awaited first!");
6552 const nativeResponseValue = wasm.TS_TxOut_new(script_pubkey, value);
6553 return nativeResponseValue;
6555 // void TxOut_free(struct LDKTxOut _res);
6557 export function TxOut_free(_res: number): void {
6558 if(!isWasmInitialized) {
6559 throw new Error("initializeWasm() must be awaited first!");
6561 const nativeResponseValue = wasm.TS_TxOut_free(_res);
6562 // debug statements here
6564 // uintptr_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg);
6566 export function TxOut_clone_ptr(arg: number): number {
6567 if(!isWasmInitialized) {
6568 throw new Error("initializeWasm() must be awaited first!");
6570 const nativeResponseValue = wasm.TS_TxOut_clone_ptr(arg);
6571 return nativeResponseValue;
6573 // struct LDKTxOut TxOut_clone(const struct LDKTxOut *NONNULL_PTR orig);
6575 export function TxOut_clone(orig: number): number {
6576 if(!isWasmInitialized) {
6577 throw new Error("initializeWasm() must be awaited first!");
6579 const nativeResponseValue = wasm.TS_TxOut_clone(orig);
6580 return nativeResponseValue;
6582 // void Str_free(struct LDKStr _res);
6584 export function Str_free(_res: number): void {
6585 if(!isWasmInitialized) {
6586 throw new Error("initializeWasm() must be awaited first!");
6588 const nativeResponseValue = wasm.TS_Str_free(_res);
6589 // debug statements here
6591 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_ok(void);
6593 export function CResult_NoneNoneZ_ok(): number {
6594 if(!isWasmInitialized) {
6595 throw new Error("initializeWasm() must be awaited first!");
6597 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_ok();
6598 return nativeResponseValue;
6600 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_err(void);
6602 export function CResult_NoneNoneZ_err(): number {
6603 if(!isWasmInitialized) {
6604 throw new Error("initializeWasm() must be awaited first!");
6606 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_err();
6607 return nativeResponseValue;
6609 // bool CResult_NoneNoneZ_is_ok(const struct LDKCResult_NoneNoneZ *NONNULL_PTR o);
6611 export function CResult_NoneNoneZ_is_ok(o: number): boolean {
6612 if(!isWasmInitialized) {
6613 throw new Error("initializeWasm() must be awaited first!");
6615 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_is_ok(o);
6616 return nativeResponseValue;
6618 // void CResult_NoneNoneZ_free(struct LDKCResult_NoneNoneZ _res);
6620 export function CResult_NoneNoneZ_free(_res: number): void {
6621 if(!isWasmInitialized) {
6622 throw new Error("initializeWasm() must be awaited first!");
6624 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_free(_res);
6625 // debug statements here
6627 // uintptr_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg);
6629 export function CResult_NoneNoneZ_clone_ptr(arg: number): number {
6630 if(!isWasmInitialized) {
6631 throw new Error("initializeWasm() must be awaited first!");
6633 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone_ptr(arg);
6634 return nativeResponseValue;
6636 // struct LDKCResult_NoneNoneZ CResult_NoneNoneZ_clone(const struct LDKCResult_NoneNoneZ *NONNULL_PTR orig);
6638 export function CResult_NoneNoneZ_clone(orig: number): number {
6639 if(!isWasmInitialized) {
6640 throw new Error("initializeWasm() must be awaited first!");
6642 const nativeResponseValue = wasm.TS_CResult_NoneNoneZ_clone(orig);
6643 return nativeResponseValue;
6645 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(struct LDKCounterpartyCommitmentSecrets o);
6647 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o: number): number {
6648 if(!isWasmInitialized) {
6649 throw new Error("initializeWasm() must be awaited first!");
6651 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o);
6652 return nativeResponseValue;
6654 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(struct LDKDecodeError e);
6656 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e: number): number {
6657 if(!isWasmInitialized) {
6658 throw new Error("initializeWasm() must be awaited first!");
6660 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e);
6661 return nativeResponseValue;
6663 // bool CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR o);
6665 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o: number): boolean {
6666 if(!isWasmInitialized) {
6667 throw new Error("initializeWasm() must be awaited first!");
6669 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o);
6670 return nativeResponseValue;
6672 // void CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res);
6674 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res: number): void {
6675 if(!isWasmInitialized) {
6676 throw new Error("initializeWasm() must be awaited first!");
6678 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res);
6679 // debug statements here
6681 // uintptr_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg);
6683 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg: number): number {
6684 if(!isWasmInitialized) {
6685 throw new Error("initializeWasm() must be awaited first!");
6687 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg);
6688 return nativeResponseValue;
6690 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(const struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR orig);
6692 export function CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig: number): number {
6693 if(!isWasmInitialized) {
6694 throw new Error("initializeWasm() must be awaited first!");
6696 const nativeResponseValue = wasm.TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig);
6697 return nativeResponseValue;
6699 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
6701 export function CResult_SecretKeyErrorZ_ok(o: number): number {
6702 if(!isWasmInitialized) {
6703 throw new Error("initializeWasm() must be awaited first!");
6705 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_ok(o);
6706 return nativeResponseValue;
6708 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_err(enum LDKSecp256k1Error e);
6710 export function CResult_SecretKeyErrorZ_err(e: Secp256k1Error): number {
6711 if(!isWasmInitialized) {
6712 throw new Error("initializeWasm() must be awaited first!");
6714 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_err(e);
6715 return nativeResponseValue;
6717 // bool CResult_SecretKeyErrorZ_is_ok(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR o);
6719 export function CResult_SecretKeyErrorZ_is_ok(o: number): boolean {
6720 if(!isWasmInitialized) {
6721 throw new Error("initializeWasm() must be awaited first!");
6723 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_is_ok(o);
6724 return nativeResponseValue;
6726 // void CResult_SecretKeyErrorZ_free(struct LDKCResult_SecretKeyErrorZ _res);
6728 export function CResult_SecretKeyErrorZ_free(_res: number): void {
6729 if(!isWasmInitialized) {
6730 throw new Error("initializeWasm() must be awaited first!");
6732 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_free(_res);
6733 // debug statements here
6735 // uintptr_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg);
6737 export function CResult_SecretKeyErrorZ_clone_ptr(arg: number): number {
6738 if(!isWasmInitialized) {
6739 throw new Error("initializeWasm() must be awaited first!");
6741 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone_ptr(arg);
6742 return nativeResponseValue;
6744 // struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_clone(const struct LDKCResult_SecretKeyErrorZ *NONNULL_PTR orig);
6746 export function CResult_SecretKeyErrorZ_clone(orig: number): number {
6747 if(!isWasmInitialized) {
6748 throw new Error("initializeWasm() must be awaited first!");
6750 const nativeResponseValue = wasm.TS_CResult_SecretKeyErrorZ_clone(orig);
6751 return nativeResponseValue;
6753 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_ok(struct LDKPublicKey o);
6755 export function CResult_PublicKeyErrorZ_ok(o: number): number {
6756 if(!isWasmInitialized) {
6757 throw new Error("initializeWasm() must be awaited first!");
6759 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_ok(o);
6760 return nativeResponseValue;
6762 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_err(enum LDKSecp256k1Error e);
6764 export function CResult_PublicKeyErrorZ_err(e: Secp256k1Error): number {
6765 if(!isWasmInitialized) {
6766 throw new Error("initializeWasm() must be awaited first!");
6768 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_err(e);
6769 return nativeResponseValue;
6771 // bool CResult_PublicKeyErrorZ_is_ok(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR o);
6773 export function CResult_PublicKeyErrorZ_is_ok(o: number): boolean {
6774 if(!isWasmInitialized) {
6775 throw new Error("initializeWasm() must be awaited first!");
6777 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_is_ok(o);
6778 return nativeResponseValue;
6780 // void CResult_PublicKeyErrorZ_free(struct LDKCResult_PublicKeyErrorZ _res);
6782 export function CResult_PublicKeyErrorZ_free(_res: number): void {
6783 if(!isWasmInitialized) {
6784 throw new Error("initializeWasm() must be awaited first!");
6786 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_free(_res);
6787 // debug statements here
6789 // uintptr_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg);
6791 export function CResult_PublicKeyErrorZ_clone_ptr(arg: number): number {
6792 if(!isWasmInitialized) {
6793 throw new Error("initializeWasm() must be awaited first!");
6795 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone_ptr(arg);
6796 return nativeResponseValue;
6798 // struct LDKCResult_PublicKeyErrorZ CResult_PublicKeyErrorZ_clone(const struct LDKCResult_PublicKeyErrorZ *NONNULL_PTR orig);
6800 export function CResult_PublicKeyErrorZ_clone(orig: number): number {
6801 if(!isWasmInitialized) {
6802 throw new Error("initializeWasm() must be awaited first!");
6804 const nativeResponseValue = wasm.TS_CResult_PublicKeyErrorZ_clone(orig);
6805 return nativeResponseValue;
6807 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_ok(struct LDKTxCreationKeys o);
6809 export function CResult_TxCreationKeysDecodeErrorZ_ok(o: number): number {
6810 if(!isWasmInitialized) {
6811 throw new Error("initializeWasm() must be awaited first!");
6813 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_ok(o);
6814 return nativeResponseValue;
6816 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_err(struct LDKDecodeError e);
6818 export function CResult_TxCreationKeysDecodeErrorZ_err(e: number): number {
6819 if(!isWasmInitialized) {
6820 throw new Error("initializeWasm() must be awaited first!");
6822 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_err(e);
6823 return nativeResponseValue;
6825 // bool CResult_TxCreationKeysDecodeErrorZ_is_ok(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR o);
6827 export function CResult_TxCreationKeysDecodeErrorZ_is_ok(o: number): boolean {
6828 if(!isWasmInitialized) {
6829 throw new Error("initializeWasm() must be awaited first!");
6831 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(o);
6832 return nativeResponseValue;
6834 // void CResult_TxCreationKeysDecodeErrorZ_free(struct LDKCResult_TxCreationKeysDecodeErrorZ _res);
6836 export function CResult_TxCreationKeysDecodeErrorZ_free(_res: number): void {
6837 if(!isWasmInitialized) {
6838 throw new Error("initializeWasm() must be awaited first!");
6840 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_free(_res);
6841 // debug statements here
6843 // uintptr_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg);
6845 export function CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg: number): number {
6846 if(!isWasmInitialized) {
6847 throw new Error("initializeWasm() must be awaited first!");
6849 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg);
6850 return nativeResponseValue;
6852 // struct LDKCResult_TxCreationKeysDecodeErrorZ CResult_TxCreationKeysDecodeErrorZ_clone(const struct LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR orig);
6854 export function CResult_TxCreationKeysDecodeErrorZ_clone(orig: number): number {
6855 if(!isWasmInitialized) {
6856 throw new Error("initializeWasm() must be awaited first!");
6858 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysDecodeErrorZ_clone(orig);
6859 return nativeResponseValue;
6861 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_ok(struct LDKChannelPublicKeys o);
6863 export function CResult_ChannelPublicKeysDecodeErrorZ_ok(o: number): number {
6864 if(!isWasmInitialized) {
6865 throw new Error("initializeWasm() must be awaited first!");
6867 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(o);
6868 return nativeResponseValue;
6870 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_err(struct LDKDecodeError e);
6872 export function CResult_ChannelPublicKeysDecodeErrorZ_err(e: number): number {
6873 if(!isWasmInitialized) {
6874 throw new Error("initializeWasm() must be awaited first!");
6876 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_err(e);
6877 return nativeResponseValue;
6879 // bool CResult_ChannelPublicKeysDecodeErrorZ_is_ok(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR o);
6881 export function CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o: number): boolean {
6882 if(!isWasmInitialized) {
6883 throw new Error("initializeWasm() must be awaited first!");
6885 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o);
6886 return nativeResponseValue;
6888 // void CResult_ChannelPublicKeysDecodeErrorZ_free(struct LDKCResult_ChannelPublicKeysDecodeErrorZ _res);
6890 export function CResult_ChannelPublicKeysDecodeErrorZ_free(_res: number): void {
6891 if(!isWasmInitialized) {
6892 throw new Error("initializeWasm() must be awaited first!");
6894 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_free(_res);
6895 // debug statements here
6897 // uintptr_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg);
6899 export function CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg: number): number {
6900 if(!isWasmInitialized) {
6901 throw new Error("initializeWasm() must be awaited first!");
6903 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg);
6904 return nativeResponseValue;
6906 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ CResult_ChannelPublicKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR orig);
6908 export function CResult_ChannelPublicKeysDecodeErrorZ_clone(orig: number): number {
6909 if(!isWasmInitialized) {
6910 throw new Error("initializeWasm() must be awaited first!");
6912 const nativeResponseValue = wasm.TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(orig);
6913 return nativeResponseValue;
6915 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_ok(struct LDKTxCreationKeys o);
6917 export function CResult_TxCreationKeysErrorZ_ok(o: number): number {
6918 if(!isWasmInitialized) {
6919 throw new Error("initializeWasm() must be awaited first!");
6921 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_ok(o);
6922 return nativeResponseValue;
6924 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_err(enum LDKSecp256k1Error e);
6926 export function CResult_TxCreationKeysErrorZ_err(e: Secp256k1Error): number {
6927 if(!isWasmInitialized) {
6928 throw new Error("initializeWasm() must be awaited first!");
6930 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_err(e);
6931 return nativeResponseValue;
6933 // bool CResult_TxCreationKeysErrorZ_is_ok(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR o);
6935 export function CResult_TxCreationKeysErrorZ_is_ok(o: number): boolean {
6936 if(!isWasmInitialized) {
6937 throw new Error("initializeWasm() must be awaited first!");
6939 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_is_ok(o);
6940 return nativeResponseValue;
6942 // void CResult_TxCreationKeysErrorZ_free(struct LDKCResult_TxCreationKeysErrorZ _res);
6944 export function CResult_TxCreationKeysErrorZ_free(_res: number): void {
6945 if(!isWasmInitialized) {
6946 throw new Error("initializeWasm() must be awaited first!");
6948 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_free(_res);
6949 // debug statements here
6951 // uintptr_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg);
6953 export function CResult_TxCreationKeysErrorZ_clone_ptr(arg: number): number {
6954 if(!isWasmInitialized) {
6955 throw new Error("initializeWasm() must be awaited first!");
6957 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone_ptr(arg);
6958 return nativeResponseValue;
6960 // struct LDKCResult_TxCreationKeysErrorZ CResult_TxCreationKeysErrorZ_clone(const struct LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR orig);
6962 export function CResult_TxCreationKeysErrorZ_clone(orig: number): number {
6963 if(!isWasmInitialized) {
6964 throw new Error("initializeWasm() must be awaited first!");
6966 const nativeResponseValue = wasm.TS_CResult_TxCreationKeysErrorZ_clone(orig);
6967 return nativeResponseValue;
6969 // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
6971 export function COption_u32Z_some(o: number): number {
6972 if(!isWasmInitialized) {
6973 throw new Error("initializeWasm() must be awaited first!");
6975 const nativeResponseValue = wasm.TS_COption_u32Z_some(o);
6976 return nativeResponseValue;
6978 // struct LDKCOption_u32Z COption_u32Z_none(void);
6980 export function COption_u32Z_none(): number {
6981 if(!isWasmInitialized) {
6982 throw new Error("initializeWasm() must be awaited first!");
6984 const nativeResponseValue = wasm.TS_COption_u32Z_none();
6985 return nativeResponseValue;
6987 // void COption_u32Z_free(struct LDKCOption_u32Z _res);
6989 export function COption_u32Z_free(_res: number): void {
6990 if(!isWasmInitialized) {
6991 throw new Error("initializeWasm() must be awaited first!");
6993 const nativeResponseValue = wasm.TS_COption_u32Z_free(_res);
6994 // debug statements here
6996 // uintptr_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg);
6998 export function COption_u32Z_clone_ptr(arg: number): number {
6999 if(!isWasmInitialized) {
7000 throw new Error("initializeWasm() must be awaited first!");
7002 const nativeResponseValue = wasm.TS_COption_u32Z_clone_ptr(arg);
7003 return nativeResponseValue;
7005 // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
7007 export function COption_u32Z_clone(orig: number): number {
7008 if(!isWasmInitialized) {
7009 throw new Error("initializeWasm() must be awaited first!");
7011 const nativeResponseValue = wasm.TS_COption_u32Z_clone(orig);
7012 return nativeResponseValue;
7014 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
7016 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
7017 if(!isWasmInitialized) {
7018 throw new Error("initializeWasm() must be awaited first!");
7020 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o);
7021 return nativeResponseValue;
7023 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_err(struct LDKDecodeError e);
7025 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e: number): number {
7026 if(!isWasmInitialized) {
7027 throw new Error("initializeWasm() must be awaited first!");
7029 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e);
7030 return nativeResponseValue;
7032 // bool CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR o);
7034 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o: number): boolean {
7035 if(!isWasmInitialized) {
7036 throw new Error("initializeWasm() must be awaited first!");
7038 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o);
7039 return nativeResponseValue;
7041 // void CResult_HTLCOutputInCommitmentDecodeErrorZ_free(struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res);
7043 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res: number): void {
7044 if(!isWasmInitialized) {
7045 throw new Error("initializeWasm() must be awaited first!");
7047 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res);
7048 // debug statements here
7050 // uintptr_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg);
7052 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg: number): number {
7053 if(!isWasmInitialized) {
7054 throw new Error("initializeWasm() must be awaited first!");
7056 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg);
7057 return nativeResponseValue;
7059 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(const struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR orig);
7061 export function CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig: number): number {
7062 if(!isWasmInitialized) {
7063 throw new Error("initializeWasm() must be awaited first!");
7065 const nativeResponseValue = wasm.TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig);
7066 return nativeResponseValue;
7068 // enum LDKCOption_NoneZ COption_NoneZ_some(void);
7070 export function COption_NoneZ_some(): COption_NoneZ {
7071 if(!isWasmInitialized) {
7072 throw new Error("initializeWasm() must be awaited first!");
7074 const nativeResponseValue = wasm.TS_COption_NoneZ_some();
7075 return nativeResponseValue;
7077 // enum LDKCOption_NoneZ COption_NoneZ_none(void);
7079 export function COption_NoneZ_none(): COption_NoneZ {
7080 if(!isWasmInitialized) {
7081 throw new Error("initializeWasm() must be awaited first!");
7083 const nativeResponseValue = wasm.TS_COption_NoneZ_none();
7084 return nativeResponseValue;
7086 // void COption_NoneZ_free(enum LDKCOption_NoneZ _res);
7088 export function COption_NoneZ_free(_res: COption_NoneZ): void {
7089 if(!isWasmInitialized) {
7090 throw new Error("initializeWasm() must be awaited first!");
7092 const nativeResponseValue = wasm.TS_COption_NoneZ_free(_res);
7093 // debug statements here
7095 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(struct LDKCounterpartyChannelTransactionParameters o);
7097 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
7098 if(!isWasmInitialized) {
7099 throw new Error("initializeWasm() must be awaited first!");
7101 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o);
7102 return nativeResponseValue;
7104 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7106 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e: number): number {
7107 if(!isWasmInitialized) {
7108 throw new Error("initializeWasm() must be awaited first!");
7110 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e);
7111 return nativeResponseValue;
7113 // bool CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7115 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
7116 if(!isWasmInitialized) {
7117 throw new Error("initializeWasm() must be awaited first!");
7119 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o);
7120 return nativeResponseValue;
7122 // void CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res);
7124 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
7125 if(!isWasmInitialized) {
7126 throw new Error("initializeWasm() must be awaited first!");
7128 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res);
7129 // debug statements here
7131 // uintptr_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7133 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
7134 if(!isWasmInitialized) {
7135 throw new Error("initializeWasm() must be awaited first!");
7137 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7138 return nativeResponseValue;
7140 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7142 export function CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
7143 if(!isWasmInitialized) {
7144 throw new Error("initializeWasm() must be awaited first!");
7146 const nativeResponseValue = wasm.TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig);
7147 return nativeResponseValue;
7149 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_ok(struct LDKChannelTransactionParameters o);
7151 export function CResult_ChannelTransactionParametersDecodeErrorZ_ok(o: number): number {
7152 if(!isWasmInitialized) {
7153 throw new Error("initializeWasm() must be awaited first!");
7155 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(o);
7156 return nativeResponseValue;
7158 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_err(struct LDKDecodeError e);
7160 export function CResult_ChannelTransactionParametersDecodeErrorZ_err(e: number): number {
7161 if(!isWasmInitialized) {
7162 throw new Error("initializeWasm() must be awaited first!");
7164 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(e);
7165 return nativeResponseValue;
7167 // bool CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR o);
7169 export function CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o: number): boolean {
7170 if(!isWasmInitialized) {
7171 throw new Error("initializeWasm() must be awaited first!");
7173 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o);
7174 return nativeResponseValue;
7176 // void CResult_ChannelTransactionParametersDecodeErrorZ_free(struct LDKCResult_ChannelTransactionParametersDecodeErrorZ _res);
7178 export function CResult_ChannelTransactionParametersDecodeErrorZ_free(_res: number): void {
7179 if(!isWasmInitialized) {
7180 throw new Error("initializeWasm() must be awaited first!");
7182 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(_res);
7183 // debug statements here
7185 // uintptr_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg);
7187 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg: number): number {
7188 if(!isWasmInitialized) {
7189 throw new Error("initializeWasm() must be awaited first!");
7191 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg);
7192 return nativeResponseValue;
7194 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ CResult_ChannelTransactionParametersDecodeErrorZ_clone(const struct LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR orig);
7196 export function CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig: number): number {
7197 if(!isWasmInitialized) {
7198 throw new Error("initializeWasm() must be awaited first!");
7200 const nativeResponseValue = wasm.TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig);
7201 return nativeResponseValue;
7203 // void CVec_SignatureZ_free(struct LDKCVec_SignatureZ _res);
7205 export function CVec_SignatureZ_free(_res: number): void {
7206 if(!isWasmInitialized) {
7207 throw new Error("initializeWasm() must be awaited first!");
7209 const nativeResponseValue = wasm.TS_CVec_SignatureZ_free(_res);
7210 // debug statements here
7212 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_ok(struct LDKHolderCommitmentTransaction o);
7214 export function CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7215 if(!isWasmInitialized) {
7216 throw new Error("initializeWasm() must be awaited first!");
7218 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o);
7219 return nativeResponseValue;
7221 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7223 export function CResult_HolderCommitmentTransactionDecodeErrorZ_err(e: number): number {
7224 if(!isWasmInitialized) {
7225 throw new Error("initializeWasm() must be awaited first!");
7227 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(e);
7228 return nativeResponseValue;
7230 // bool CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7232 export function CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7233 if(!isWasmInitialized) {
7234 throw new Error("initializeWasm() must be awaited first!");
7236 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o);
7237 return nativeResponseValue;
7239 // void CResult_HolderCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res);
7241 export function CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7242 if(!isWasmInitialized) {
7243 throw new Error("initializeWasm() must be awaited first!");
7245 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res);
7246 // debug statements here
7248 // uintptr_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7250 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7251 if(!isWasmInitialized) {
7252 throw new Error("initializeWasm() must be awaited first!");
7254 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7255 return nativeResponseValue;
7257 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ CResult_HolderCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7259 export function CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7260 if(!isWasmInitialized) {
7261 throw new Error("initializeWasm() must be awaited first!");
7263 const nativeResponseValue = wasm.TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig);
7264 return nativeResponseValue;
7266 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(struct LDKBuiltCommitmentTransaction o);
7268 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o: number): number {
7269 if(!isWasmInitialized) {
7270 throw new Error("initializeWasm() must be awaited first!");
7272 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o);
7273 return nativeResponseValue;
7275 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7277 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e: number): number {
7278 if(!isWasmInitialized) {
7279 throw new Error("initializeWasm() must be awaited first!");
7281 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e);
7282 return nativeResponseValue;
7284 // bool CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7286 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7287 if(!isWasmInitialized) {
7288 throw new Error("initializeWasm() must be awaited first!");
7290 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o);
7291 return nativeResponseValue;
7293 // void CResult_BuiltCommitmentTransactionDecodeErrorZ_free(struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res);
7295 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res: number): void {
7296 if(!isWasmInitialized) {
7297 throw new Error("initializeWasm() must be awaited first!");
7299 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res);
7300 // debug statements here
7302 // uintptr_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7304 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7305 if(!isWasmInitialized) {
7306 throw new Error("initializeWasm() must be awaited first!");
7308 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7309 return nativeResponseValue;
7311 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7313 export function CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7314 if(!isWasmInitialized) {
7315 throw new Error("initializeWasm() must be awaited first!");
7317 const nativeResponseValue = wasm.TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig);
7318 return nativeResponseValue;
7320 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_ok(struct LDKTrustedClosingTransaction o);
7322 export function CResult_TrustedClosingTransactionNoneZ_ok(o: number): number {
7323 if(!isWasmInitialized) {
7324 throw new Error("initializeWasm() must be awaited first!");
7326 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_ok(o);
7327 return nativeResponseValue;
7329 // struct LDKCResult_TrustedClosingTransactionNoneZ CResult_TrustedClosingTransactionNoneZ_err(void);
7331 export function CResult_TrustedClosingTransactionNoneZ_err(): number {
7332 if(!isWasmInitialized) {
7333 throw new Error("initializeWasm() must be awaited first!");
7335 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_err();
7336 return nativeResponseValue;
7338 // bool CResult_TrustedClosingTransactionNoneZ_is_ok(const struct LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR o);
7340 export function CResult_TrustedClosingTransactionNoneZ_is_ok(o: number): boolean {
7341 if(!isWasmInitialized) {
7342 throw new Error("initializeWasm() must be awaited first!");
7344 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_is_ok(o);
7345 return nativeResponseValue;
7347 // void CResult_TrustedClosingTransactionNoneZ_free(struct LDKCResult_TrustedClosingTransactionNoneZ _res);
7349 export function CResult_TrustedClosingTransactionNoneZ_free(_res: number): void {
7350 if(!isWasmInitialized) {
7351 throw new Error("initializeWasm() must be awaited first!");
7353 const nativeResponseValue = wasm.TS_CResult_TrustedClosingTransactionNoneZ_free(_res);
7354 // debug statements here
7356 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_ok(struct LDKCommitmentTransaction o);
7358 export function CResult_CommitmentTransactionDecodeErrorZ_ok(o: number): number {
7359 if(!isWasmInitialized) {
7360 throw new Error("initializeWasm() must be awaited first!");
7362 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_ok(o);
7363 return nativeResponseValue;
7365 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_err(struct LDKDecodeError e);
7367 export function CResult_CommitmentTransactionDecodeErrorZ_err(e: number): number {
7368 if(!isWasmInitialized) {
7369 throw new Error("initializeWasm() must be awaited first!");
7371 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_err(e);
7372 return nativeResponseValue;
7374 // bool CResult_CommitmentTransactionDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR o);
7376 export function CResult_CommitmentTransactionDecodeErrorZ_is_ok(o: number): boolean {
7377 if(!isWasmInitialized) {
7378 throw new Error("initializeWasm() must be awaited first!");
7380 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(o);
7381 return nativeResponseValue;
7383 // void CResult_CommitmentTransactionDecodeErrorZ_free(struct LDKCResult_CommitmentTransactionDecodeErrorZ _res);
7385 export function CResult_CommitmentTransactionDecodeErrorZ_free(_res: number): void {
7386 if(!isWasmInitialized) {
7387 throw new Error("initializeWasm() must be awaited first!");
7389 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_free(_res);
7390 // debug statements here
7392 // uintptr_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg);
7394 export function CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg: number): number {
7395 if(!isWasmInitialized) {
7396 throw new Error("initializeWasm() must be awaited first!");
7398 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg);
7399 return nativeResponseValue;
7401 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CResult_CommitmentTransactionDecodeErrorZ_clone(const struct LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR orig);
7403 export function CResult_CommitmentTransactionDecodeErrorZ_clone(orig: number): number {
7404 if(!isWasmInitialized) {
7405 throw new Error("initializeWasm() must be awaited first!");
7407 const nativeResponseValue = wasm.TS_CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
7408 return nativeResponseValue;
7410 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
7412 export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
7413 if(!isWasmInitialized) {
7414 throw new Error("initializeWasm() must be awaited first!");
7416 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_ok(o);
7417 return nativeResponseValue;
7419 // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
7421 export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
7422 if(!isWasmInitialized) {
7423 throw new Error("initializeWasm() must be awaited first!");
7425 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_err();
7426 return nativeResponseValue;
7428 // bool CResult_TrustedCommitmentTransactionNoneZ_is_ok(const struct LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR o);
7430 export function CResult_TrustedCommitmentTransactionNoneZ_is_ok(o: number): boolean {
7431 if(!isWasmInitialized) {
7432 throw new Error("initializeWasm() must be awaited first!");
7434 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(o);
7435 return nativeResponseValue;
7437 // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
7439 export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
7440 if(!isWasmInitialized) {
7441 throw new Error("initializeWasm() must be awaited first!");
7443 const nativeResponseValue = wasm.TS_CResult_TrustedCommitmentTransactionNoneZ_free(_res);
7444 // debug statements here
7446 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
7448 export function CResult_CVec_SignatureZNoneZ_ok(o: number): number {
7449 if(!isWasmInitialized) {
7450 throw new Error("initializeWasm() must be awaited first!");
7452 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_ok(o);
7453 return nativeResponseValue;
7455 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
7457 export function CResult_CVec_SignatureZNoneZ_err(): number {
7458 if(!isWasmInitialized) {
7459 throw new Error("initializeWasm() must be awaited first!");
7461 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_err();
7462 return nativeResponseValue;
7464 // bool CResult_CVec_SignatureZNoneZ_is_ok(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR o);
7466 export function CResult_CVec_SignatureZNoneZ_is_ok(o: number): boolean {
7467 if(!isWasmInitialized) {
7468 throw new Error("initializeWasm() must be awaited first!");
7470 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_is_ok(o);
7471 return nativeResponseValue;
7473 // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
7475 export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
7476 if(!isWasmInitialized) {
7477 throw new Error("initializeWasm() must be awaited first!");
7479 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_free(_res);
7480 // debug statements here
7482 // uintptr_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg);
7484 export function CResult_CVec_SignatureZNoneZ_clone_ptr(arg: number): number {
7485 if(!isWasmInitialized) {
7486 throw new Error("initializeWasm() must be awaited first!");
7488 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone_ptr(arg);
7489 return nativeResponseValue;
7491 // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
7493 export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
7494 if(!isWasmInitialized) {
7495 throw new Error("initializeWasm() must be awaited first!");
7497 const nativeResponseValue = wasm.TS_CResult_CVec_SignatureZNoneZ_clone(orig);
7498 return nativeResponseValue;
7500 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_ok(struct LDKShutdownScript o);
7502 export function CResult_ShutdownScriptDecodeErrorZ_ok(o: number): number {
7503 if(!isWasmInitialized) {
7504 throw new Error("initializeWasm() must be awaited first!");
7506 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_ok(o);
7507 return nativeResponseValue;
7509 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_err(struct LDKDecodeError e);
7511 export function CResult_ShutdownScriptDecodeErrorZ_err(e: number): number {
7512 if(!isWasmInitialized) {
7513 throw new Error("initializeWasm() must be awaited first!");
7515 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_err(e);
7516 return nativeResponseValue;
7518 // bool CResult_ShutdownScriptDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR o);
7520 export function CResult_ShutdownScriptDecodeErrorZ_is_ok(o: number): boolean {
7521 if(!isWasmInitialized) {
7522 throw new Error("initializeWasm() must be awaited first!");
7524 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(o);
7525 return nativeResponseValue;
7527 // void CResult_ShutdownScriptDecodeErrorZ_free(struct LDKCResult_ShutdownScriptDecodeErrorZ _res);
7529 export function CResult_ShutdownScriptDecodeErrorZ_free(_res: number): void {
7530 if(!isWasmInitialized) {
7531 throw new Error("initializeWasm() must be awaited first!");
7533 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_free(_res);
7534 // debug statements here
7536 // uintptr_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg);
7538 export function CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg: number): number {
7539 if(!isWasmInitialized) {
7540 throw new Error("initializeWasm() must be awaited first!");
7542 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg);
7543 return nativeResponseValue;
7545 // struct LDKCResult_ShutdownScriptDecodeErrorZ CResult_ShutdownScriptDecodeErrorZ_clone(const struct LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR orig);
7547 export function CResult_ShutdownScriptDecodeErrorZ_clone(orig: number): number {
7548 if(!isWasmInitialized) {
7549 throw new Error("initializeWasm() must be awaited first!");
7551 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptDecodeErrorZ_clone(orig);
7552 return nativeResponseValue;
7554 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_ok(struct LDKShutdownScript o);
7556 export function CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o: number): number {
7557 if(!isWasmInitialized) {
7558 throw new Error("initializeWasm() must be awaited first!");
7560 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o);
7561 return nativeResponseValue;
7563 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_err(struct LDKInvalidShutdownScript e);
7565 export function CResult_ShutdownScriptInvalidShutdownScriptZ_err(e: number): number {
7566 if(!isWasmInitialized) {
7567 throw new Error("initializeWasm() must be awaited first!");
7569 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(e);
7570 return nativeResponseValue;
7572 // bool CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR o);
7574 export function CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o: number): boolean {
7575 if(!isWasmInitialized) {
7576 throw new Error("initializeWasm() must be awaited first!");
7578 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o);
7579 return nativeResponseValue;
7581 // void CResult_ShutdownScriptInvalidShutdownScriptZ_free(struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res);
7583 export function CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res: number): void {
7584 if(!isWasmInitialized) {
7585 throw new Error("initializeWasm() must be awaited first!");
7587 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res);
7588 // debug statements here
7590 // uintptr_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg);
7592 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg: number): number {
7593 if(!isWasmInitialized) {
7594 throw new Error("initializeWasm() must be awaited first!");
7596 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg);
7597 return nativeResponseValue;
7599 // struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ CResult_ShutdownScriptInvalidShutdownScriptZ_clone(const struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR orig);
7601 export function CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig: number): number {
7602 if(!isWasmInitialized) {
7603 throw new Error("initializeWasm() must be awaited first!");
7605 const nativeResponseValue = wasm.TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig);
7606 return nativeResponseValue;
7608 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_ok(struct LDKRouteHop o);
7610 export function CResult_RouteHopDecodeErrorZ_ok(o: number): number {
7611 if(!isWasmInitialized) {
7612 throw new Error("initializeWasm() must be awaited first!");
7614 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_ok(o);
7615 return nativeResponseValue;
7617 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_err(struct LDKDecodeError e);
7619 export function CResult_RouteHopDecodeErrorZ_err(e: number): number {
7620 if(!isWasmInitialized) {
7621 throw new Error("initializeWasm() must be awaited first!");
7623 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_err(e);
7624 return nativeResponseValue;
7626 // bool CResult_RouteHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR o);
7628 export function CResult_RouteHopDecodeErrorZ_is_ok(o: number): boolean {
7629 if(!isWasmInitialized) {
7630 throw new Error("initializeWasm() must be awaited first!");
7632 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_is_ok(o);
7633 return nativeResponseValue;
7635 // void CResult_RouteHopDecodeErrorZ_free(struct LDKCResult_RouteHopDecodeErrorZ _res);
7637 export function CResult_RouteHopDecodeErrorZ_free(_res: number): void {
7638 if(!isWasmInitialized) {
7639 throw new Error("initializeWasm() must be awaited first!");
7641 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_free(_res);
7642 // debug statements here
7644 // uintptr_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg);
7646 export function CResult_RouteHopDecodeErrorZ_clone_ptr(arg: number): number {
7647 if(!isWasmInitialized) {
7648 throw new Error("initializeWasm() must be awaited first!");
7650 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone_ptr(arg);
7651 return nativeResponseValue;
7653 // struct LDKCResult_RouteHopDecodeErrorZ CResult_RouteHopDecodeErrorZ_clone(const struct LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR orig);
7655 export function CResult_RouteHopDecodeErrorZ_clone(orig: number): number {
7656 if(!isWasmInitialized) {
7657 throw new Error("initializeWasm() must be awaited first!");
7659 const nativeResponseValue = wasm.TS_CResult_RouteHopDecodeErrorZ_clone(orig);
7660 return nativeResponseValue;
7662 // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
7664 export function CVec_RouteHopZ_free(_res: number): void {
7665 if(!isWasmInitialized) {
7666 throw new Error("initializeWasm() must be awaited first!");
7668 const nativeResponseValue = wasm.TS_CVec_RouteHopZ_free(_res);
7669 // debug statements here
7671 // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
7673 export function CVec_CVec_RouteHopZZ_free(_res: number): void {
7674 if(!isWasmInitialized) {
7675 throw new Error("initializeWasm() must be awaited first!");
7677 const nativeResponseValue = wasm.TS_CVec_CVec_RouteHopZZ_free(_res);
7678 // debug statements here
7680 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
7682 export function CResult_RouteDecodeErrorZ_ok(o: number): number {
7683 if(!isWasmInitialized) {
7684 throw new Error("initializeWasm() must be awaited first!");
7686 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_ok(o);
7687 return nativeResponseValue;
7689 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
7691 export function CResult_RouteDecodeErrorZ_err(e: number): number {
7692 if(!isWasmInitialized) {
7693 throw new Error("initializeWasm() must be awaited first!");
7695 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_err(e);
7696 return nativeResponseValue;
7698 // bool CResult_RouteDecodeErrorZ_is_ok(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR o);
7700 export function CResult_RouteDecodeErrorZ_is_ok(o: number): boolean {
7701 if(!isWasmInitialized) {
7702 throw new Error("initializeWasm() must be awaited first!");
7704 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_is_ok(o);
7705 return nativeResponseValue;
7707 // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
7709 export function CResult_RouteDecodeErrorZ_free(_res: number): void {
7710 if(!isWasmInitialized) {
7711 throw new Error("initializeWasm() must be awaited first!");
7713 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_free(_res);
7714 // debug statements here
7716 // uintptr_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg);
7718 export function CResult_RouteDecodeErrorZ_clone_ptr(arg: number): number {
7719 if(!isWasmInitialized) {
7720 throw new Error("initializeWasm() must be awaited first!");
7722 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone_ptr(arg);
7723 return nativeResponseValue;
7725 // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
7727 export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
7728 if(!isWasmInitialized) {
7729 throw new Error("initializeWasm() must be awaited first!");
7731 const nativeResponseValue = wasm.TS_CResult_RouteDecodeErrorZ_clone(orig);
7732 return nativeResponseValue;
7734 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_ok(struct LDKRouteParameters o);
7736 export function CResult_RouteParametersDecodeErrorZ_ok(o: number): number {
7737 if(!isWasmInitialized) {
7738 throw new Error("initializeWasm() must be awaited first!");
7740 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_ok(o);
7741 return nativeResponseValue;
7743 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_err(struct LDKDecodeError e);
7745 export function CResult_RouteParametersDecodeErrorZ_err(e: number): number {
7746 if(!isWasmInitialized) {
7747 throw new Error("initializeWasm() must be awaited first!");
7749 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_err(e);
7750 return nativeResponseValue;
7752 // bool CResult_RouteParametersDecodeErrorZ_is_ok(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR o);
7754 export function CResult_RouteParametersDecodeErrorZ_is_ok(o: number): boolean {
7755 if(!isWasmInitialized) {
7756 throw new Error("initializeWasm() must be awaited first!");
7758 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_is_ok(o);
7759 return nativeResponseValue;
7761 // void CResult_RouteParametersDecodeErrorZ_free(struct LDKCResult_RouteParametersDecodeErrorZ _res);
7763 export function CResult_RouteParametersDecodeErrorZ_free(_res: number): void {
7764 if(!isWasmInitialized) {
7765 throw new Error("initializeWasm() must be awaited first!");
7767 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_free(_res);
7768 // debug statements here
7770 // uintptr_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg);
7772 export function CResult_RouteParametersDecodeErrorZ_clone_ptr(arg: number): number {
7773 if(!isWasmInitialized) {
7774 throw new Error("initializeWasm() must be awaited first!");
7776 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(arg);
7777 return nativeResponseValue;
7779 // struct LDKCResult_RouteParametersDecodeErrorZ CResult_RouteParametersDecodeErrorZ_clone(const struct LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR orig);
7781 export function CResult_RouteParametersDecodeErrorZ_clone(orig: number): number {
7782 if(!isWasmInitialized) {
7783 throw new Error("initializeWasm() must be awaited first!");
7785 const nativeResponseValue = wasm.TS_CResult_RouteParametersDecodeErrorZ_clone(orig);
7786 return nativeResponseValue;
7788 // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
7790 export function CVec_RouteHintZ_free(_res: number): void {
7791 if(!isWasmInitialized) {
7792 throw new Error("initializeWasm() must be awaited first!");
7794 const nativeResponseValue = wasm.TS_CVec_RouteHintZ_free(_res);
7795 // debug statements here
7797 // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
7799 export function COption_u64Z_some(o: bigint): number {
7800 if(!isWasmInitialized) {
7801 throw new Error("initializeWasm() must be awaited first!");
7803 const nativeResponseValue = wasm.TS_COption_u64Z_some(o);
7804 return nativeResponseValue;
7806 // struct LDKCOption_u64Z COption_u64Z_none(void);
7808 export function COption_u64Z_none(): number {
7809 if(!isWasmInitialized) {
7810 throw new Error("initializeWasm() must be awaited first!");
7812 const nativeResponseValue = wasm.TS_COption_u64Z_none();
7813 return nativeResponseValue;
7815 // void COption_u64Z_free(struct LDKCOption_u64Z _res);
7817 export function COption_u64Z_free(_res: number): void {
7818 if(!isWasmInitialized) {
7819 throw new Error("initializeWasm() must be awaited first!");
7821 const nativeResponseValue = wasm.TS_COption_u64Z_free(_res);
7822 // debug statements here
7824 // uintptr_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg);
7826 export function COption_u64Z_clone_ptr(arg: number): number {
7827 if(!isWasmInitialized) {
7828 throw new Error("initializeWasm() must be awaited first!");
7830 const nativeResponseValue = wasm.TS_COption_u64Z_clone_ptr(arg);
7831 return nativeResponseValue;
7833 // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
7835 export function COption_u64Z_clone(orig: number): number {
7836 if(!isWasmInitialized) {
7837 throw new Error("initializeWasm() must be awaited first!");
7839 const nativeResponseValue = wasm.TS_COption_u64Z_clone(orig);
7840 return nativeResponseValue;
7842 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_ok(struct LDKPaymentParameters o);
7844 export function CResult_PaymentParametersDecodeErrorZ_ok(o: number): number {
7845 if(!isWasmInitialized) {
7846 throw new Error("initializeWasm() must be awaited first!");
7848 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_ok(o);
7849 return nativeResponseValue;
7851 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_err(struct LDKDecodeError e);
7853 export function CResult_PaymentParametersDecodeErrorZ_err(e: number): number {
7854 if(!isWasmInitialized) {
7855 throw new Error("initializeWasm() must be awaited first!");
7857 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_err(e);
7858 return nativeResponseValue;
7860 // bool CResult_PaymentParametersDecodeErrorZ_is_ok(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR o);
7862 export function CResult_PaymentParametersDecodeErrorZ_is_ok(o: number): boolean {
7863 if(!isWasmInitialized) {
7864 throw new Error("initializeWasm() must be awaited first!");
7866 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_is_ok(o);
7867 return nativeResponseValue;
7869 // void CResult_PaymentParametersDecodeErrorZ_free(struct LDKCResult_PaymentParametersDecodeErrorZ _res);
7871 export function CResult_PaymentParametersDecodeErrorZ_free(_res: number): void {
7872 if(!isWasmInitialized) {
7873 throw new Error("initializeWasm() must be awaited first!");
7875 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_free(_res);
7876 // debug statements here
7878 // uintptr_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg);
7880 export function CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg: number): number {
7881 if(!isWasmInitialized) {
7882 throw new Error("initializeWasm() must be awaited first!");
7884 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg);
7885 return nativeResponseValue;
7887 // struct LDKCResult_PaymentParametersDecodeErrorZ CResult_PaymentParametersDecodeErrorZ_clone(const struct LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR orig);
7889 export function CResult_PaymentParametersDecodeErrorZ_clone(orig: number): number {
7890 if(!isWasmInitialized) {
7891 throw new Error("initializeWasm() must be awaited first!");
7893 const nativeResponseValue = wasm.TS_CResult_PaymentParametersDecodeErrorZ_clone(orig);
7894 return nativeResponseValue;
7896 // void CVec_RouteHintHopZ_free(struct LDKCVec_RouteHintHopZ _res);
7898 export function CVec_RouteHintHopZ_free(_res: number): void {
7899 if(!isWasmInitialized) {
7900 throw new Error("initializeWasm() must be awaited first!");
7902 const nativeResponseValue = wasm.TS_CVec_RouteHintHopZ_free(_res);
7903 // debug statements here
7905 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_ok(struct LDKRouteHint o);
7907 export function CResult_RouteHintDecodeErrorZ_ok(o: number): number {
7908 if(!isWasmInitialized) {
7909 throw new Error("initializeWasm() must be awaited first!");
7911 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_ok(o);
7912 return nativeResponseValue;
7914 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_err(struct LDKDecodeError e);
7916 export function CResult_RouteHintDecodeErrorZ_err(e: number): number {
7917 if(!isWasmInitialized) {
7918 throw new Error("initializeWasm() must be awaited first!");
7920 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_err(e);
7921 return nativeResponseValue;
7923 // bool CResult_RouteHintDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR o);
7925 export function CResult_RouteHintDecodeErrorZ_is_ok(o: number): boolean {
7926 if(!isWasmInitialized) {
7927 throw new Error("initializeWasm() must be awaited first!");
7929 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_is_ok(o);
7930 return nativeResponseValue;
7932 // void CResult_RouteHintDecodeErrorZ_free(struct LDKCResult_RouteHintDecodeErrorZ _res);
7934 export function CResult_RouteHintDecodeErrorZ_free(_res: number): void {
7935 if(!isWasmInitialized) {
7936 throw new Error("initializeWasm() must be awaited first!");
7938 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_free(_res);
7939 // debug statements here
7941 // uintptr_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg);
7943 export function CResult_RouteHintDecodeErrorZ_clone_ptr(arg: number): number {
7944 if(!isWasmInitialized) {
7945 throw new Error("initializeWasm() must be awaited first!");
7947 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone_ptr(arg);
7948 return nativeResponseValue;
7950 // struct LDKCResult_RouteHintDecodeErrorZ CResult_RouteHintDecodeErrorZ_clone(const struct LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR orig);
7952 export function CResult_RouteHintDecodeErrorZ_clone(orig: number): number {
7953 if(!isWasmInitialized) {
7954 throw new Error("initializeWasm() must be awaited first!");
7956 const nativeResponseValue = wasm.TS_CResult_RouteHintDecodeErrorZ_clone(orig);
7957 return nativeResponseValue;
7959 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_ok(struct LDKRouteHintHop o);
7961 export function CResult_RouteHintHopDecodeErrorZ_ok(o: number): number {
7962 if(!isWasmInitialized) {
7963 throw new Error("initializeWasm() must be awaited first!");
7965 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_ok(o);
7966 return nativeResponseValue;
7968 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_err(struct LDKDecodeError e);
7970 export function CResult_RouteHintHopDecodeErrorZ_err(e: number): number {
7971 if(!isWasmInitialized) {
7972 throw new Error("initializeWasm() must be awaited first!");
7974 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_err(e);
7975 return nativeResponseValue;
7977 // bool CResult_RouteHintHopDecodeErrorZ_is_ok(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR o);
7979 export function CResult_RouteHintHopDecodeErrorZ_is_ok(o: number): boolean {
7980 if(!isWasmInitialized) {
7981 throw new Error("initializeWasm() must be awaited first!");
7983 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_is_ok(o);
7984 return nativeResponseValue;
7986 // void CResult_RouteHintHopDecodeErrorZ_free(struct LDKCResult_RouteHintHopDecodeErrorZ _res);
7988 export function CResult_RouteHintHopDecodeErrorZ_free(_res: number): void {
7989 if(!isWasmInitialized) {
7990 throw new Error("initializeWasm() must be awaited first!");
7992 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_free(_res);
7993 // debug statements here
7995 // uintptr_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg);
7997 export function CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg: number): number {
7998 if(!isWasmInitialized) {
7999 throw new Error("initializeWasm() must be awaited first!");
8001 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg);
8002 return nativeResponseValue;
8004 // struct LDKCResult_RouteHintHopDecodeErrorZ CResult_RouteHintHopDecodeErrorZ_clone(const struct LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR orig);
8006 export function CResult_RouteHintHopDecodeErrorZ_clone(orig: number): number {
8007 if(!isWasmInitialized) {
8008 throw new Error("initializeWasm() must be awaited first!");
8010 const nativeResponseValue = wasm.TS_CResult_RouteHintHopDecodeErrorZ_clone(orig);
8011 return nativeResponseValue;
8013 // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
8015 export function CVec_ChannelDetailsZ_free(_res: number): void {
8016 if(!isWasmInitialized) {
8017 throw new Error("initializeWasm() must be awaited first!");
8019 const nativeResponseValue = wasm.TS_CVec_ChannelDetailsZ_free(_res);
8020 // debug statements here
8022 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
8024 export function CResult_RouteLightningErrorZ_ok(o: number): number {
8025 if(!isWasmInitialized) {
8026 throw new Error("initializeWasm() must be awaited first!");
8028 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_ok(o);
8029 return nativeResponseValue;
8031 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
8033 export function CResult_RouteLightningErrorZ_err(e: number): number {
8034 if(!isWasmInitialized) {
8035 throw new Error("initializeWasm() must be awaited first!");
8037 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_err(e);
8038 return nativeResponseValue;
8040 // bool CResult_RouteLightningErrorZ_is_ok(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR o);
8042 export function CResult_RouteLightningErrorZ_is_ok(o: number): boolean {
8043 if(!isWasmInitialized) {
8044 throw new Error("initializeWasm() must be awaited first!");
8046 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_is_ok(o);
8047 return nativeResponseValue;
8049 // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
8051 export function CResult_RouteLightningErrorZ_free(_res: number): void {
8052 if(!isWasmInitialized) {
8053 throw new Error("initializeWasm() must be awaited first!");
8055 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_free(_res);
8056 // debug statements here
8058 // uintptr_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg);
8060 export function CResult_RouteLightningErrorZ_clone_ptr(arg: number): number {
8061 if(!isWasmInitialized) {
8062 throw new Error("initializeWasm() must be awaited first!");
8064 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone_ptr(arg);
8065 return nativeResponseValue;
8067 // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
8069 export function CResult_RouteLightningErrorZ_clone(orig: number): number {
8070 if(!isWasmInitialized) {
8071 throw new Error("initializeWasm() must be awaited first!");
8073 const nativeResponseValue = wasm.TS_CResult_RouteLightningErrorZ_clone(orig);
8074 return nativeResponseValue;
8076 // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
8078 export function CVec_PublicKeyZ_free(_res: number): void {
8079 if(!isWasmInitialized) {
8080 throw new Error("initializeWasm() must be awaited first!");
8082 const nativeResponseValue = wasm.TS_CVec_PublicKeyZ_free(_res);
8083 // debug statements here
8085 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_ok(struct LDKPaymentPurpose o);
8087 export function CResult_PaymentPurposeDecodeErrorZ_ok(o: number): number {
8088 if(!isWasmInitialized) {
8089 throw new Error("initializeWasm() must be awaited first!");
8091 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_ok(o);
8092 return nativeResponseValue;
8094 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_err(struct LDKDecodeError e);
8096 export function CResult_PaymentPurposeDecodeErrorZ_err(e: number): number {
8097 if(!isWasmInitialized) {
8098 throw new Error("initializeWasm() must be awaited first!");
8100 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_err(e);
8101 return nativeResponseValue;
8103 // bool CResult_PaymentPurposeDecodeErrorZ_is_ok(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR o);
8105 export function CResult_PaymentPurposeDecodeErrorZ_is_ok(o: number): boolean {
8106 if(!isWasmInitialized) {
8107 throw new Error("initializeWasm() must be awaited first!");
8109 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(o);
8110 return nativeResponseValue;
8112 // void CResult_PaymentPurposeDecodeErrorZ_free(struct LDKCResult_PaymentPurposeDecodeErrorZ _res);
8114 export function CResult_PaymentPurposeDecodeErrorZ_free(_res: number): void {
8115 if(!isWasmInitialized) {
8116 throw new Error("initializeWasm() must be awaited first!");
8118 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_free(_res);
8119 // debug statements here
8121 // uintptr_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg);
8123 export function CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg: number): number {
8124 if(!isWasmInitialized) {
8125 throw new Error("initializeWasm() must be awaited first!");
8127 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg);
8128 return nativeResponseValue;
8130 // struct LDKCResult_PaymentPurposeDecodeErrorZ CResult_PaymentPurposeDecodeErrorZ_clone(const struct LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR orig);
8132 export function CResult_PaymentPurposeDecodeErrorZ_clone(orig: number): number {
8133 if(!isWasmInitialized) {
8134 throw new Error("initializeWasm() must be awaited first!");
8136 const nativeResponseValue = wasm.TS_CResult_PaymentPurposeDecodeErrorZ_clone(orig);
8137 return nativeResponseValue;
8139 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_some(struct LDKClosureReason o);
8141 export function COption_ClosureReasonZ_some(o: number): number {
8142 if(!isWasmInitialized) {
8143 throw new Error("initializeWasm() must be awaited first!");
8145 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_some(o);
8146 return nativeResponseValue;
8148 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_none(void);
8150 export function COption_ClosureReasonZ_none(): number {
8151 if(!isWasmInitialized) {
8152 throw new Error("initializeWasm() must be awaited first!");
8154 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_none();
8155 return nativeResponseValue;
8157 // void COption_ClosureReasonZ_free(struct LDKCOption_ClosureReasonZ _res);
8159 export function COption_ClosureReasonZ_free(_res: number): void {
8160 if(!isWasmInitialized) {
8161 throw new Error("initializeWasm() must be awaited first!");
8163 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_free(_res);
8164 // debug statements here
8166 // uintptr_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg);
8168 export function COption_ClosureReasonZ_clone_ptr(arg: number): number {
8169 if(!isWasmInitialized) {
8170 throw new Error("initializeWasm() must be awaited first!");
8172 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone_ptr(arg);
8173 return nativeResponseValue;
8175 // struct LDKCOption_ClosureReasonZ COption_ClosureReasonZ_clone(const struct LDKCOption_ClosureReasonZ *NONNULL_PTR orig);
8177 export function COption_ClosureReasonZ_clone(orig: number): number {
8178 if(!isWasmInitialized) {
8179 throw new Error("initializeWasm() must be awaited first!");
8181 const nativeResponseValue = wasm.TS_COption_ClosureReasonZ_clone(orig);
8182 return nativeResponseValue;
8184 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_ok(struct LDKCOption_ClosureReasonZ o);
8186 export function CResult_COption_ClosureReasonZDecodeErrorZ_ok(o: number): number {
8187 if(!isWasmInitialized) {
8188 throw new Error("initializeWasm() must be awaited first!");
8190 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(o);
8191 return nativeResponseValue;
8193 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_err(struct LDKDecodeError e);
8195 export function CResult_COption_ClosureReasonZDecodeErrorZ_err(e: number): number {
8196 if(!isWasmInitialized) {
8197 throw new Error("initializeWasm() must be awaited first!");
8199 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(e);
8200 return nativeResponseValue;
8202 // bool CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR o);
8204 export function CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o: number): boolean {
8205 if(!isWasmInitialized) {
8206 throw new Error("initializeWasm() must be awaited first!");
8208 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o);
8209 return nativeResponseValue;
8211 // void CResult_COption_ClosureReasonZDecodeErrorZ_free(struct LDKCResult_COption_ClosureReasonZDecodeErrorZ _res);
8213 export function CResult_COption_ClosureReasonZDecodeErrorZ_free(_res: number): void {
8214 if(!isWasmInitialized) {
8215 throw new Error("initializeWasm() must be awaited first!");
8217 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(_res);
8218 // debug statements here
8220 // uintptr_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg);
8222 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg: number): number {
8223 if(!isWasmInitialized) {
8224 throw new Error("initializeWasm() must be awaited first!");
8226 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg);
8227 return nativeResponseValue;
8229 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ CResult_COption_ClosureReasonZDecodeErrorZ_clone(const struct LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR orig);
8231 export function CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig: number): number {
8232 if(!isWasmInitialized) {
8233 throw new Error("initializeWasm() must be awaited first!");
8235 const nativeResponseValue = wasm.TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig);
8236 return nativeResponseValue;
8238 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_some(struct LDKNetworkUpdate o);
8240 export function COption_NetworkUpdateZ_some(o: number): number {
8241 if(!isWasmInitialized) {
8242 throw new Error("initializeWasm() must be awaited first!");
8244 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_some(o);
8245 return nativeResponseValue;
8247 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_none(void);
8249 export function COption_NetworkUpdateZ_none(): number {
8250 if(!isWasmInitialized) {
8251 throw new Error("initializeWasm() must be awaited first!");
8253 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_none();
8254 return nativeResponseValue;
8256 // void COption_NetworkUpdateZ_free(struct LDKCOption_NetworkUpdateZ _res);
8258 export function COption_NetworkUpdateZ_free(_res: number): void {
8259 if(!isWasmInitialized) {
8260 throw new Error("initializeWasm() must be awaited first!");
8262 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_free(_res);
8263 // debug statements here
8265 // uintptr_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg);
8267 export function COption_NetworkUpdateZ_clone_ptr(arg: number): number {
8268 if(!isWasmInitialized) {
8269 throw new Error("initializeWasm() must be awaited first!");
8271 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone_ptr(arg);
8272 return nativeResponseValue;
8274 // struct LDKCOption_NetworkUpdateZ COption_NetworkUpdateZ_clone(const struct LDKCOption_NetworkUpdateZ *NONNULL_PTR orig);
8276 export function COption_NetworkUpdateZ_clone(orig: number): number {
8277 if(!isWasmInitialized) {
8278 throw new Error("initializeWasm() must be awaited first!");
8280 const nativeResponseValue = wasm.TS_COption_NetworkUpdateZ_clone(orig);
8281 return nativeResponseValue;
8283 // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
8285 export function CVec_SpendableOutputDescriptorZ_free(_res: number): void {
8286 if(!isWasmInitialized) {
8287 throw new Error("initializeWasm() must be awaited first!");
8289 const nativeResponseValue = wasm.TS_CVec_SpendableOutputDescriptorZ_free(_res);
8290 // debug statements here
8292 // struct LDKCOption_EventZ COption_EventZ_some(struct LDKEvent o);
8294 export function COption_EventZ_some(o: number): number {
8295 if(!isWasmInitialized) {
8296 throw new Error("initializeWasm() must be awaited first!");
8298 const nativeResponseValue = wasm.TS_COption_EventZ_some(o);
8299 return nativeResponseValue;
8301 // struct LDKCOption_EventZ COption_EventZ_none(void);
8303 export function COption_EventZ_none(): number {
8304 if(!isWasmInitialized) {
8305 throw new Error("initializeWasm() must be awaited first!");
8307 const nativeResponseValue = wasm.TS_COption_EventZ_none();
8308 return nativeResponseValue;
8310 // void COption_EventZ_free(struct LDKCOption_EventZ _res);
8312 export function COption_EventZ_free(_res: number): void {
8313 if(!isWasmInitialized) {
8314 throw new Error("initializeWasm() must be awaited first!");
8316 const nativeResponseValue = wasm.TS_COption_EventZ_free(_res);
8317 // debug statements here
8319 // uintptr_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg);
8321 export function COption_EventZ_clone_ptr(arg: number): number {
8322 if(!isWasmInitialized) {
8323 throw new Error("initializeWasm() must be awaited first!");
8325 const nativeResponseValue = wasm.TS_COption_EventZ_clone_ptr(arg);
8326 return nativeResponseValue;
8328 // struct LDKCOption_EventZ COption_EventZ_clone(const struct LDKCOption_EventZ *NONNULL_PTR orig);
8330 export function COption_EventZ_clone(orig: number): number {
8331 if(!isWasmInitialized) {
8332 throw new Error("initializeWasm() must be awaited first!");
8334 const nativeResponseValue = wasm.TS_COption_EventZ_clone(orig);
8335 return nativeResponseValue;
8337 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_ok(struct LDKCOption_EventZ o);
8339 export function CResult_COption_EventZDecodeErrorZ_ok(o: number): number {
8340 if(!isWasmInitialized) {
8341 throw new Error("initializeWasm() must be awaited first!");
8343 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_ok(o);
8344 return nativeResponseValue;
8346 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_err(struct LDKDecodeError e);
8348 export function CResult_COption_EventZDecodeErrorZ_err(e: number): number {
8349 if(!isWasmInitialized) {
8350 throw new Error("initializeWasm() must be awaited first!");
8352 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_err(e);
8353 return nativeResponseValue;
8355 // bool CResult_COption_EventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR o);
8357 export function CResult_COption_EventZDecodeErrorZ_is_ok(o: number): boolean {
8358 if(!isWasmInitialized) {
8359 throw new Error("initializeWasm() must be awaited first!");
8361 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_is_ok(o);
8362 return nativeResponseValue;
8364 // void CResult_COption_EventZDecodeErrorZ_free(struct LDKCResult_COption_EventZDecodeErrorZ _res);
8366 export function CResult_COption_EventZDecodeErrorZ_free(_res: number): void {
8367 if(!isWasmInitialized) {
8368 throw new Error("initializeWasm() must be awaited first!");
8370 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_free(_res);
8371 // debug statements here
8373 // uintptr_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg);
8375 export function CResult_COption_EventZDecodeErrorZ_clone_ptr(arg: number): number {
8376 if(!isWasmInitialized) {
8377 throw new Error("initializeWasm() must be awaited first!");
8379 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(arg);
8380 return nativeResponseValue;
8382 // struct LDKCResult_COption_EventZDecodeErrorZ CResult_COption_EventZDecodeErrorZ_clone(const struct LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR orig);
8384 export function CResult_COption_EventZDecodeErrorZ_clone(orig: number): number {
8385 if(!isWasmInitialized) {
8386 throw new Error("initializeWasm() must be awaited first!");
8388 const nativeResponseValue = wasm.TS_CResult_COption_EventZDecodeErrorZ_clone(orig);
8389 return nativeResponseValue;
8391 // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
8393 export function CVec_MessageSendEventZ_free(_res: number): void {
8394 if(!isWasmInitialized) {
8395 throw new Error("initializeWasm() must be awaited first!");
8397 const nativeResponseValue = wasm.TS_CVec_MessageSendEventZ_free(_res);
8398 // debug statements here
8400 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
8402 export function CResult_TxOutAccessErrorZ_ok(o: number): number {
8403 if(!isWasmInitialized) {
8404 throw new Error("initializeWasm() must be awaited first!");
8406 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_ok(o);
8407 return nativeResponseValue;
8409 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
8411 export function CResult_TxOutAccessErrorZ_err(e: AccessError): number {
8412 if(!isWasmInitialized) {
8413 throw new Error("initializeWasm() must be awaited first!");
8415 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_err(e);
8416 return nativeResponseValue;
8418 // bool CResult_TxOutAccessErrorZ_is_ok(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR o);
8420 export function CResult_TxOutAccessErrorZ_is_ok(o: number): boolean {
8421 if(!isWasmInitialized) {
8422 throw new Error("initializeWasm() must be awaited first!");
8424 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_is_ok(o);
8425 return nativeResponseValue;
8427 // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
8429 export function CResult_TxOutAccessErrorZ_free(_res: number): void {
8430 if(!isWasmInitialized) {
8431 throw new Error("initializeWasm() must be awaited first!");
8433 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_free(_res);
8434 // debug statements here
8436 // uintptr_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg);
8438 export function CResult_TxOutAccessErrorZ_clone_ptr(arg: number): number {
8439 if(!isWasmInitialized) {
8440 throw new Error("initializeWasm() must be awaited first!");
8442 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone_ptr(arg);
8443 return nativeResponseValue;
8445 // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
8447 export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
8448 if(!isWasmInitialized) {
8449 throw new Error("initializeWasm() must be awaited first!");
8451 const nativeResponseValue = wasm.TS_CResult_TxOutAccessErrorZ_clone(orig);
8452 return nativeResponseValue;
8454 // uintptr_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg);
8456 export function C2Tuple_usizeTransactionZ_clone_ptr(arg: number): number {
8457 if(!isWasmInitialized) {
8458 throw new Error("initializeWasm() must be awaited first!");
8460 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone_ptr(arg);
8461 return nativeResponseValue;
8463 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_clone(const struct LDKC2Tuple_usizeTransactionZ *NONNULL_PTR orig);
8465 export function C2Tuple_usizeTransactionZ_clone(orig: number): number {
8466 if(!isWasmInitialized) {
8467 throw new Error("initializeWasm() must be awaited first!");
8469 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_clone(orig);
8470 return nativeResponseValue;
8472 // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
8474 export function C2Tuple_usizeTransactionZ_new(a: number, b: number): number {
8475 if(!isWasmInitialized) {
8476 throw new Error("initializeWasm() must be awaited first!");
8478 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_new(a, b);
8479 return nativeResponseValue;
8481 // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
8483 export function C2Tuple_usizeTransactionZ_free(_res: number): void {
8484 if(!isWasmInitialized) {
8485 throw new Error("initializeWasm() must be awaited first!");
8487 const nativeResponseValue = wasm.TS_C2Tuple_usizeTransactionZ_free(_res);
8488 // debug statements here
8490 // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
8492 export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8493 if(!isWasmInitialized) {
8494 throw new Error("initializeWasm() must be awaited first!");
8496 const nativeResponseValue = wasm.TS_CVec_C2Tuple_usizeTransactionZZ_free(_res);
8497 // debug statements here
8499 // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
8501 export function CVec_TxidZ_free(_res: number): void {
8502 if(!isWasmInitialized) {
8503 throw new Error("initializeWasm() must be awaited first!");
8505 const nativeResponseValue = wasm.TS_CVec_TxidZ_free(_res);
8506 // debug statements here
8508 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
8510 export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
8511 if(!isWasmInitialized) {
8512 throw new Error("initializeWasm() must be awaited first!");
8514 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_ok();
8515 return nativeResponseValue;
8517 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
8519 export function CResult_NoneChannelMonitorUpdateErrZ_err(e: ChannelMonitorUpdateErr): number {
8520 if(!isWasmInitialized) {
8521 throw new Error("initializeWasm() must be awaited first!");
8523 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_err(e);
8524 return nativeResponseValue;
8526 // bool CResult_NoneChannelMonitorUpdateErrZ_is_ok(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR o);
8528 export function CResult_NoneChannelMonitorUpdateErrZ_is_ok(o: number): boolean {
8529 if(!isWasmInitialized) {
8530 throw new Error("initializeWasm() must be awaited first!");
8532 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(o);
8533 return nativeResponseValue;
8535 // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
8537 export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
8538 if(!isWasmInitialized) {
8539 throw new Error("initializeWasm() must be awaited first!");
8541 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_free(_res);
8542 // debug statements here
8544 // uintptr_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg);
8546 export function CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg: number): number {
8547 if(!isWasmInitialized) {
8548 throw new Error("initializeWasm() must be awaited first!");
8550 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg);
8551 return nativeResponseValue;
8553 // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
8555 export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
8556 if(!isWasmInitialized) {
8557 throw new Error("initializeWasm() must be awaited first!");
8559 const nativeResponseValue = wasm.TS_CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
8560 return nativeResponseValue;
8562 // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
8564 export function CVec_MonitorEventZ_free(_res: number): void {
8565 if(!isWasmInitialized) {
8566 throw new Error("initializeWasm() must be awaited first!");
8568 const nativeResponseValue = wasm.TS_CVec_MonitorEventZ_free(_res);
8569 // debug statements here
8571 // uintptr_t C2Tuple_OutPointCVec_MonitorEventZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR arg);
8573 export function C2Tuple_OutPointCVec_MonitorEventZZ_clone_ptr(arg: number): number {
8574 if(!isWasmInitialized) {
8575 throw new Error("initializeWasm() must be awaited first!");
8577 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_clone_ptr(arg);
8578 return nativeResponseValue;
8580 // struct LDKC2Tuple_OutPointCVec_MonitorEventZZ C2Tuple_OutPointCVec_MonitorEventZZ_clone(const struct LDKC2Tuple_OutPointCVec_MonitorEventZZ *NONNULL_PTR orig);
8582 export function C2Tuple_OutPointCVec_MonitorEventZZ_clone(orig: number): number {
8583 if(!isWasmInitialized) {
8584 throw new Error("initializeWasm() must be awaited first!");
8586 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_clone(orig);
8587 return nativeResponseValue;
8589 // struct LDKC2Tuple_OutPointCVec_MonitorEventZZ C2Tuple_OutPointCVec_MonitorEventZZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorEventZ b);
8591 export function C2Tuple_OutPointCVec_MonitorEventZZ_new(a: number, b: number): number {
8592 if(!isWasmInitialized) {
8593 throw new Error("initializeWasm() must be awaited first!");
8595 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_new(a, b);
8596 return nativeResponseValue;
8598 // void C2Tuple_OutPointCVec_MonitorEventZZ_free(struct LDKC2Tuple_OutPointCVec_MonitorEventZZ _res);
8600 export function C2Tuple_OutPointCVec_MonitorEventZZ_free(_res: number): void {
8601 if(!isWasmInitialized) {
8602 throw new Error("initializeWasm() must be awaited first!");
8604 const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorEventZZ_free(_res);
8605 // debug statements here
8607 // void CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(struct LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ _res);
8609 export function CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(_res: number): void {
8610 if(!isWasmInitialized) {
8611 throw new Error("initializeWasm() must be awaited first!");
8613 const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorEventZZZ_free(_res);
8614 // debug statements here
8616 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
8618 export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
8619 if(!isWasmInitialized) {
8620 throw new Error("initializeWasm() must be awaited first!");
8622 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_some(o);
8623 return nativeResponseValue;
8625 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
8627 export function COption_C2Tuple_usizeTransactionZZ_none(): number {
8628 if(!isWasmInitialized) {
8629 throw new Error("initializeWasm() must be awaited first!");
8631 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_none();
8632 return nativeResponseValue;
8634 // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
8636 export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
8637 if(!isWasmInitialized) {
8638 throw new Error("initializeWasm() must be awaited first!");
8640 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_free(_res);
8641 // debug statements here
8643 // uintptr_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg);
8645 export function COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg: number): number {
8646 if(!isWasmInitialized) {
8647 throw new Error("initializeWasm() must be awaited first!");
8649 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg);
8650 return nativeResponseValue;
8652 // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_clone(const struct LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR orig);
8654 export function COption_C2Tuple_usizeTransactionZZ_clone(orig: number): number {
8655 if(!isWasmInitialized) {
8656 throw new Error("initializeWasm() must be awaited first!");
8658 const nativeResponseValue = wasm.TS_COption_C2Tuple_usizeTransactionZZ_clone(orig);
8659 return nativeResponseValue;
8661 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_ok(struct LDKFixedPenaltyScorer o);
8663 export function CResult_FixedPenaltyScorerDecodeErrorZ_ok(o: number): number {
8664 if(!isWasmInitialized) {
8665 throw new Error("initializeWasm() must be awaited first!");
8667 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(o);
8668 return nativeResponseValue;
8670 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_err(struct LDKDecodeError e);
8672 export function CResult_FixedPenaltyScorerDecodeErrorZ_err(e: number): number {
8673 if(!isWasmInitialized) {
8674 throw new Error("initializeWasm() must be awaited first!");
8676 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(e);
8677 return nativeResponseValue;
8679 // bool CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR o);
8681 export function CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o: number): boolean {
8682 if(!isWasmInitialized) {
8683 throw new Error("initializeWasm() must be awaited first!");
8685 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o);
8686 return nativeResponseValue;
8688 // void CResult_FixedPenaltyScorerDecodeErrorZ_free(struct LDKCResult_FixedPenaltyScorerDecodeErrorZ _res);
8690 export function CResult_FixedPenaltyScorerDecodeErrorZ_free(_res: number): void {
8691 if(!isWasmInitialized) {
8692 throw new Error("initializeWasm() must be awaited first!");
8694 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(_res);
8695 // debug statements here
8697 // uintptr_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg);
8699 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg: number): number {
8700 if(!isWasmInitialized) {
8701 throw new Error("initializeWasm() must be awaited first!");
8703 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg);
8704 return nativeResponseValue;
8706 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ CResult_FixedPenaltyScorerDecodeErrorZ_clone(const struct LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR orig);
8708 export function CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig: number): number {
8709 if(!isWasmInitialized) {
8710 throw new Error("initializeWasm() must be awaited first!");
8712 const nativeResponseValue = wasm.TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig);
8713 return nativeResponseValue;
8715 // uintptr_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg);
8717 export function C2Tuple_u64u64Z_clone_ptr(arg: number): number {
8718 if(!isWasmInitialized) {
8719 throw new Error("initializeWasm() must be awaited first!");
8721 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone_ptr(arg);
8722 return nativeResponseValue;
8724 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig);
8726 export function C2Tuple_u64u64Z_clone(orig: number): number {
8727 if(!isWasmInitialized) {
8728 throw new Error("initializeWasm() must be awaited first!");
8730 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_clone(orig);
8731 return nativeResponseValue;
8733 // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b);
8735 export function C2Tuple_u64u64Z_new(a: bigint, b: bigint): number {
8736 if(!isWasmInitialized) {
8737 throw new Error("initializeWasm() must be awaited first!");
8739 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_new(a, b);
8740 return nativeResponseValue;
8742 // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res);
8744 export function C2Tuple_u64u64Z_free(_res: number): void {
8745 if(!isWasmInitialized) {
8746 throw new Error("initializeWasm() must be awaited first!");
8748 const nativeResponseValue = wasm.TS_C2Tuple_u64u64Z_free(_res);
8749 // debug statements here
8751 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_some(struct LDKC2Tuple_u64u64Z o);
8753 export function COption_C2Tuple_u64u64ZZ_some(o: number): number {
8754 if(!isWasmInitialized) {
8755 throw new Error("initializeWasm() must be awaited first!");
8757 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_some(o);
8758 return nativeResponseValue;
8760 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_none(void);
8762 export function COption_C2Tuple_u64u64ZZ_none(): number {
8763 if(!isWasmInitialized) {
8764 throw new Error("initializeWasm() must be awaited first!");
8766 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_none();
8767 return nativeResponseValue;
8769 // void COption_C2Tuple_u64u64ZZ_free(struct LDKCOption_C2Tuple_u64u64ZZ _res);
8771 export function COption_C2Tuple_u64u64ZZ_free(_res: number): void {
8772 if(!isWasmInitialized) {
8773 throw new Error("initializeWasm() must be awaited first!");
8775 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_free(_res);
8776 // debug statements here
8778 // uintptr_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg);
8780 export function COption_C2Tuple_u64u64ZZ_clone_ptr(arg: number): number {
8781 if(!isWasmInitialized) {
8782 throw new Error("initializeWasm() must be awaited first!");
8784 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone_ptr(arg);
8785 return nativeResponseValue;
8787 // struct LDKCOption_C2Tuple_u64u64ZZ COption_C2Tuple_u64u64ZZ_clone(const struct LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR orig);
8789 export function COption_C2Tuple_u64u64ZZ_clone(orig: number): number {
8790 if(!isWasmInitialized) {
8791 throw new Error("initializeWasm() must be awaited first!");
8793 const nativeResponseValue = wasm.TS_COption_C2Tuple_u64u64ZZ_clone(orig);
8794 return nativeResponseValue;
8796 // void CVec_NodeIdZ_free(struct LDKCVec_NodeIdZ _res);
8798 export function CVec_NodeIdZ_free(_res: number): void {
8799 if(!isWasmInitialized) {
8800 throw new Error("initializeWasm() must be awaited first!");
8802 const nativeResponseValue = wasm.TS_CVec_NodeIdZ_free(_res);
8803 // debug statements here
8805 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_ok(struct LDKProbabilisticScorer o);
8807 export function CResult_ProbabilisticScorerDecodeErrorZ_ok(o: number): number {
8808 if(!isWasmInitialized) {
8809 throw new Error("initializeWasm() must be awaited first!");
8811 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(o);
8812 return nativeResponseValue;
8814 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ CResult_ProbabilisticScorerDecodeErrorZ_err(struct LDKDecodeError e);
8816 export function CResult_ProbabilisticScorerDecodeErrorZ_err(e: number): number {
8817 if(!isWasmInitialized) {
8818 throw new Error("initializeWasm() must be awaited first!");
8820 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_err(e);
8821 return nativeResponseValue;
8823 // bool CResult_ProbabilisticScorerDecodeErrorZ_is_ok(const struct LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR o);
8825 export function CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o: number): boolean {
8826 if(!isWasmInitialized) {
8827 throw new Error("initializeWasm() must be awaited first!");
8829 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o);
8830 return nativeResponseValue;
8832 // void CResult_ProbabilisticScorerDecodeErrorZ_free(struct LDKCResult_ProbabilisticScorerDecodeErrorZ _res);
8834 export function CResult_ProbabilisticScorerDecodeErrorZ_free(_res: number): void {
8835 if(!isWasmInitialized) {
8836 throw new Error("initializeWasm() must be awaited first!");
8838 const nativeResponseValue = wasm.TS_CResult_ProbabilisticScorerDecodeErrorZ_free(_res);
8839 // debug statements here
8841 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
8843 export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
8844 if(!isWasmInitialized) {
8845 throw new Error("initializeWasm() must be awaited first!");
8847 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_ok(o);
8848 return nativeResponseValue;
8850 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8852 export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
8853 if(!isWasmInitialized) {
8854 throw new Error("initializeWasm() must be awaited first!");
8856 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_err(e);
8857 return nativeResponseValue;
8859 // bool CResult_InitFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR o);
8861 export function CResult_InitFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8862 if(!isWasmInitialized) {
8863 throw new Error("initializeWasm() must be awaited first!");
8865 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_is_ok(o);
8866 return nativeResponseValue;
8868 // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
8870 export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
8871 if(!isWasmInitialized) {
8872 throw new Error("initializeWasm() must be awaited first!");
8874 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_free(_res);
8875 // debug statements here
8877 // uintptr_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg);
8879 export function CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8880 if(!isWasmInitialized) {
8881 throw new Error("initializeWasm() must be awaited first!");
8883 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg);
8884 return nativeResponseValue;
8886 // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_clone(const struct LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR orig);
8888 export function CResult_InitFeaturesDecodeErrorZ_clone(orig: number): number {
8889 if(!isWasmInitialized) {
8890 throw new Error("initializeWasm() must be awaited first!");
8892 const nativeResponseValue = wasm.TS_CResult_InitFeaturesDecodeErrorZ_clone(orig);
8893 return nativeResponseValue;
8895 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
8897 export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
8898 if(!isWasmInitialized) {
8899 throw new Error("initializeWasm() must be awaited first!");
8901 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_ok(o);
8902 return nativeResponseValue;
8904 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8906 export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
8907 if(!isWasmInitialized) {
8908 throw new Error("initializeWasm() must be awaited first!");
8910 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_err(e);
8911 return nativeResponseValue;
8913 // bool CResult_ChannelFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR o);
8915 export function CResult_ChannelFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8916 if(!isWasmInitialized) {
8917 throw new Error("initializeWasm() must be awaited first!");
8919 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(o);
8920 return nativeResponseValue;
8922 // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
8924 export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
8925 if(!isWasmInitialized) {
8926 throw new Error("initializeWasm() must be awaited first!");
8928 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_free(_res);
8929 // debug statements here
8931 // uintptr_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg);
8933 export function CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8934 if(!isWasmInitialized) {
8935 throw new Error("initializeWasm() must be awaited first!");
8937 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg);
8938 return nativeResponseValue;
8940 // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR orig);
8942 export function CResult_ChannelFeaturesDecodeErrorZ_clone(orig: number): number {
8943 if(!isWasmInitialized) {
8944 throw new Error("initializeWasm() must be awaited first!");
8946 const nativeResponseValue = wasm.TS_CResult_ChannelFeaturesDecodeErrorZ_clone(orig);
8947 return nativeResponseValue;
8949 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
8951 export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
8952 if(!isWasmInitialized) {
8953 throw new Error("initializeWasm() must be awaited first!");
8955 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_ok(o);
8956 return nativeResponseValue;
8958 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
8960 export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
8961 if(!isWasmInitialized) {
8962 throw new Error("initializeWasm() must be awaited first!");
8964 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_err(e);
8965 return nativeResponseValue;
8967 // bool CResult_NodeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR o);
8969 export function CResult_NodeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
8970 if(!isWasmInitialized) {
8971 throw new Error("initializeWasm() must be awaited first!");
8973 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(o);
8974 return nativeResponseValue;
8976 // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
8978 export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
8979 if(!isWasmInitialized) {
8980 throw new Error("initializeWasm() must be awaited first!");
8982 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_free(_res);
8983 // debug statements here
8985 // uintptr_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg);
8987 export function CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
8988 if(!isWasmInitialized) {
8989 throw new Error("initializeWasm() must be awaited first!");
8991 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg);
8992 return nativeResponseValue;
8994 // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_clone(const struct LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR orig);
8996 export function CResult_NodeFeaturesDecodeErrorZ_clone(orig: number): number {
8997 if(!isWasmInitialized) {
8998 throw new Error("initializeWasm() must be awaited first!");
9000 const nativeResponseValue = wasm.TS_CResult_NodeFeaturesDecodeErrorZ_clone(orig);
9001 return nativeResponseValue;
9003 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
9005 export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
9006 if(!isWasmInitialized) {
9007 throw new Error("initializeWasm() must be awaited first!");
9009 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
9010 return nativeResponseValue;
9012 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9014 export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
9015 if(!isWasmInitialized) {
9016 throw new Error("initializeWasm() must be awaited first!");
9018 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_err(e);
9019 return nativeResponseValue;
9021 // bool CResult_InvoiceFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR o);
9023 export function CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9024 if(!isWasmInitialized) {
9025 throw new Error("initializeWasm() must be awaited first!");
9027 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o);
9028 return nativeResponseValue;
9030 // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
9032 export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
9033 if(!isWasmInitialized) {
9034 throw new Error("initializeWasm() must be awaited first!");
9036 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
9037 // debug statements here
9039 // uintptr_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg);
9041 export function CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9042 if(!isWasmInitialized) {
9043 throw new Error("initializeWasm() must be awaited first!");
9045 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg);
9046 return nativeResponseValue;
9048 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_clone(const struct LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR orig);
9050 export function CResult_InvoiceFeaturesDecodeErrorZ_clone(orig: number): number {
9051 if(!isWasmInitialized) {
9052 throw new Error("initializeWasm() must be awaited first!");
9054 const nativeResponseValue = wasm.TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(orig);
9055 return nativeResponseValue;
9057 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_ok(struct LDKChannelTypeFeatures o);
9059 export function CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o: number): number {
9060 if(!isWasmInitialized) {
9061 throw new Error("initializeWasm() must be awaited first!");
9063 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o);
9064 return nativeResponseValue;
9066 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
9068 export function CResult_ChannelTypeFeaturesDecodeErrorZ_err(e: number): number {
9069 if(!isWasmInitialized) {
9070 throw new Error("initializeWasm() must be awaited first!");
9072 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(e);
9073 return nativeResponseValue;
9075 // bool CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR o);
9077 export function CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o: number): boolean {
9078 if(!isWasmInitialized) {
9079 throw new Error("initializeWasm() must be awaited first!");
9081 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o);
9082 return nativeResponseValue;
9084 // void CResult_ChannelTypeFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res);
9086 export function CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res: number): void {
9087 if(!isWasmInitialized) {
9088 throw new Error("initializeWasm() must be awaited first!");
9090 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res);
9091 // debug statements here
9093 // uintptr_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg);
9095 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg: number): number {
9096 if(!isWasmInitialized) {
9097 throw new Error("initializeWasm() must be awaited first!");
9099 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg);
9100 return nativeResponseValue;
9102 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ CResult_ChannelTypeFeaturesDecodeErrorZ_clone(const struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR orig);
9104 export function CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig: number): number {
9105 if(!isWasmInitialized) {
9106 throw new Error("initializeWasm() must be awaited first!");
9108 const nativeResponseValue = wasm.TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig);
9109 return nativeResponseValue;
9111 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_ok(struct LDKNodeId o);
9113 export function CResult_NodeIdDecodeErrorZ_ok(o: number): number {
9114 if(!isWasmInitialized) {
9115 throw new Error("initializeWasm() must be awaited first!");
9117 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_ok(o);
9118 return nativeResponseValue;
9120 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_err(struct LDKDecodeError e);
9122 export function CResult_NodeIdDecodeErrorZ_err(e: number): number {
9123 if(!isWasmInitialized) {
9124 throw new Error("initializeWasm() must be awaited first!");
9126 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_err(e);
9127 return nativeResponseValue;
9129 // bool CResult_NodeIdDecodeErrorZ_is_ok(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR o);
9131 export function CResult_NodeIdDecodeErrorZ_is_ok(o: number): boolean {
9132 if(!isWasmInitialized) {
9133 throw new Error("initializeWasm() must be awaited first!");
9135 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_is_ok(o);
9136 return nativeResponseValue;
9138 // void CResult_NodeIdDecodeErrorZ_free(struct LDKCResult_NodeIdDecodeErrorZ _res);
9140 export function CResult_NodeIdDecodeErrorZ_free(_res: number): void {
9141 if(!isWasmInitialized) {
9142 throw new Error("initializeWasm() must be awaited first!");
9144 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_free(_res);
9145 // debug statements here
9147 // uintptr_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg);
9149 export function CResult_NodeIdDecodeErrorZ_clone_ptr(arg: number): number {
9150 if(!isWasmInitialized) {
9151 throw new Error("initializeWasm() must be awaited first!");
9153 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone_ptr(arg);
9154 return nativeResponseValue;
9156 // struct LDKCResult_NodeIdDecodeErrorZ CResult_NodeIdDecodeErrorZ_clone(const struct LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR orig);
9158 export function CResult_NodeIdDecodeErrorZ_clone(orig: number): number {
9159 if(!isWasmInitialized) {
9160 throw new Error("initializeWasm() must be awaited first!");
9162 const nativeResponseValue = wasm.TS_CResult_NodeIdDecodeErrorZ_clone(orig);
9163 return nativeResponseValue;
9165 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_ok(struct LDKCOption_NetworkUpdateZ o);
9167 export function CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o: number): number {
9168 if(!isWasmInitialized) {
9169 throw new Error("initializeWasm() must be awaited first!");
9171 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o);
9172 return nativeResponseValue;
9174 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_err(struct LDKDecodeError e);
9176 export function CResult_COption_NetworkUpdateZDecodeErrorZ_err(e: number): number {
9177 if(!isWasmInitialized) {
9178 throw new Error("initializeWasm() must be awaited first!");
9180 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(e);
9181 return nativeResponseValue;
9183 // bool CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR o);
9185 export function CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o: number): boolean {
9186 if(!isWasmInitialized) {
9187 throw new Error("initializeWasm() must be awaited first!");
9189 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o);
9190 return nativeResponseValue;
9192 // void CResult_COption_NetworkUpdateZDecodeErrorZ_free(struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res);
9194 export function CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res: number): void {
9195 if(!isWasmInitialized) {
9196 throw new Error("initializeWasm() must be awaited first!");
9198 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res);
9199 // debug statements here
9201 // uintptr_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg);
9203 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg: number): number {
9204 if(!isWasmInitialized) {
9205 throw new Error("initializeWasm() must be awaited first!");
9207 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg);
9208 return nativeResponseValue;
9210 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ CResult_COption_NetworkUpdateZDecodeErrorZ_clone(const struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR orig);
9212 export function CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig: number): number {
9213 if(!isWasmInitialized) {
9214 throw new Error("initializeWasm() must be awaited first!");
9216 const nativeResponseValue = wasm.TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig);
9217 return nativeResponseValue;
9219 // struct LDKCOption_AccessZ COption_AccessZ_some(struct LDKAccess o);
9221 export function COption_AccessZ_some(o: number): number {
9222 if(!isWasmInitialized) {
9223 throw new Error("initializeWasm() must be awaited first!");
9225 const nativeResponseValue = wasm.TS_COption_AccessZ_some(o);
9226 return nativeResponseValue;
9228 // struct LDKCOption_AccessZ COption_AccessZ_none(void);
9230 export function COption_AccessZ_none(): number {
9231 if(!isWasmInitialized) {
9232 throw new Error("initializeWasm() must be awaited first!");
9234 const nativeResponseValue = wasm.TS_COption_AccessZ_none();
9235 return nativeResponseValue;
9237 // void COption_AccessZ_free(struct LDKCOption_AccessZ _res);
9239 export function COption_AccessZ_free(_res: number): void {
9240 if(!isWasmInitialized) {
9241 throw new Error("initializeWasm() must be awaited first!");
9243 const nativeResponseValue = wasm.TS_COption_AccessZ_free(_res);
9244 // debug statements here
9246 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
9248 export function CResult_boolLightningErrorZ_ok(o: boolean): number {
9249 if(!isWasmInitialized) {
9250 throw new Error("initializeWasm() must be awaited first!");
9252 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_ok(o);
9253 return nativeResponseValue;
9255 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
9257 export function CResult_boolLightningErrorZ_err(e: number): number {
9258 if(!isWasmInitialized) {
9259 throw new Error("initializeWasm() must be awaited first!");
9261 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_err(e);
9262 return nativeResponseValue;
9264 // bool CResult_boolLightningErrorZ_is_ok(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR o);
9266 export function CResult_boolLightningErrorZ_is_ok(o: number): boolean {
9267 if(!isWasmInitialized) {
9268 throw new Error("initializeWasm() must be awaited first!");
9270 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_is_ok(o);
9271 return nativeResponseValue;
9273 // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
9275 export function CResult_boolLightningErrorZ_free(_res: number): void {
9276 if(!isWasmInitialized) {
9277 throw new Error("initializeWasm() must be awaited first!");
9279 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_free(_res);
9280 // debug statements here
9282 // uintptr_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg);
9284 export function CResult_boolLightningErrorZ_clone_ptr(arg: number): number {
9285 if(!isWasmInitialized) {
9286 throw new Error("initializeWasm() must be awaited first!");
9288 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone_ptr(arg);
9289 return nativeResponseValue;
9291 // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
9293 export function CResult_boolLightningErrorZ_clone(orig: number): number {
9294 if(!isWasmInitialized) {
9295 throw new Error("initializeWasm() must be awaited first!");
9297 const nativeResponseValue = wasm.TS_CResult_boolLightningErrorZ_clone(orig);
9298 return nativeResponseValue;
9300 // uintptr_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg);
9302 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg: number): number {
9303 if(!isWasmInitialized) {
9304 throw new Error("initializeWasm() must be awaited first!");
9306 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg);
9307 return nativeResponseValue;
9309 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
9311 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
9312 if(!isWasmInitialized) {
9313 throw new Error("initializeWasm() must be awaited first!");
9315 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
9316 return nativeResponseValue;
9318 // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
9320 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
9321 if(!isWasmInitialized) {
9322 throw new Error("initializeWasm() must be awaited first!");
9324 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
9325 return nativeResponseValue;
9327 // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
9329 export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
9330 if(!isWasmInitialized) {
9331 throw new Error("initializeWasm() must be awaited first!");
9333 const nativeResponseValue = wasm.TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
9334 // debug statements here
9336 // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
9338 export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number): void {
9339 if(!isWasmInitialized) {
9340 throw new Error("initializeWasm() must be awaited first!");
9342 const nativeResponseValue = wasm.TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
9343 // debug statements here
9345 // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
9347 export function CVec_NodeAnnouncementZ_free(_res: number): void {
9348 if(!isWasmInitialized) {
9349 throw new Error("initializeWasm() must be awaited first!");
9351 const nativeResponseValue = wasm.TS_CVec_NodeAnnouncementZ_free(_res);
9352 // debug statements here
9354 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
9356 export function CResult_NoneLightningErrorZ_ok(): number {
9357 if(!isWasmInitialized) {
9358 throw new Error("initializeWasm() must be awaited first!");
9360 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_ok();
9361 return nativeResponseValue;
9363 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
9365 export function CResult_NoneLightningErrorZ_err(e: number): number {
9366 if(!isWasmInitialized) {
9367 throw new Error("initializeWasm() must be awaited first!");
9369 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_err(e);
9370 return nativeResponseValue;
9372 // bool CResult_NoneLightningErrorZ_is_ok(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR o);
9374 export function CResult_NoneLightningErrorZ_is_ok(o: number): boolean {
9375 if(!isWasmInitialized) {
9376 throw new Error("initializeWasm() must be awaited first!");
9378 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_is_ok(o);
9379 return nativeResponseValue;
9381 // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
9383 export function CResult_NoneLightningErrorZ_free(_res: number): void {
9384 if(!isWasmInitialized) {
9385 throw new Error("initializeWasm() must be awaited first!");
9387 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_free(_res);
9388 // debug statements here
9390 // uintptr_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg);
9392 export function CResult_NoneLightningErrorZ_clone_ptr(arg: number): number {
9393 if(!isWasmInitialized) {
9394 throw new Error("initializeWasm() must be awaited first!");
9396 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone_ptr(arg);
9397 return nativeResponseValue;
9399 // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
9401 export function CResult_NoneLightningErrorZ_clone(orig: number): number {
9402 if(!isWasmInitialized) {
9403 throw new Error("initializeWasm() must be awaited first!");
9405 const nativeResponseValue = wasm.TS_CResult_NoneLightningErrorZ_clone(orig);
9406 return nativeResponseValue;
9408 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_ok(struct LDKChannelUpdateInfo o);
9410 export function CResult_ChannelUpdateInfoDecodeErrorZ_ok(o: number): number {
9411 if(!isWasmInitialized) {
9412 throw new Error("initializeWasm() must be awaited first!");
9414 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(o);
9415 return nativeResponseValue;
9417 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_err(struct LDKDecodeError e);
9419 export function CResult_ChannelUpdateInfoDecodeErrorZ_err(e: number): number {
9420 if(!isWasmInitialized) {
9421 throw new Error("initializeWasm() must be awaited first!");
9423 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(e);
9424 return nativeResponseValue;
9426 // bool CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR o);
9428 export function CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o: number): boolean {
9429 if(!isWasmInitialized) {
9430 throw new Error("initializeWasm() must be awaited first!");
9432 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o);
9433 return nativeResponseValue;
9435 // void CResult_ChannelUpdateInfoDecodeErrorZ_free(struct LDKCResult_ChannelUpdateInfoDecodeErrorZ _res);
9437 export function CResult_ChannelUpdateInfoDecodeErrorZ_free(_res: number): void {
9438 if(!isWasmInitialized) {
9439 throw new Error("initializeWasm() must be awaited first!");
9441 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(_res);
9442 // debug statements here
9444 // uintptr_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg);
9446 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg: number): number {
9447 if(!isWasmInitialized) {
9448 throw new Error("initializeWasm() must be awaited first!");
9450 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg);
9451 return nativeResponseValue;
9453 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ CResult_ChannelUpdateInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR orig);
9455 export function CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig: number): number {
9456 if(!isWasmInitialized) {
9457 throw new Error("initializeWasm() must be awaited first!");
9459 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig);
9460 return nativeResponseValue;
9462 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
9464 export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
9465 if(!isWasmInitialized) {
9466 throw new Error("initializeWasm() must be awaited first!");
9468 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_ok(o);
9469 return nativeResponseValue;
9471 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
9473 export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
9474 if(!isWasmInitialized) {
9475 throw new Error("initializeWasm() must be awaited first!");
9477 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_err(e);
9478 return nativeResponseValue;
9480 // bool CResult_ChannelInfoDecodeErrorZ_is_ok(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR o);
9482 export function CResult_ChannelInfoDecodeErrorZ_is_ok(o: number): boolean {
9483 if(!isWasmInitialized) {
9484 throw new Error("initializeWasm() must be awaited first!");
9486 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_is_ok(o);
9487 return nativeResponseValue;
9489 // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
9491 export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
9492 if(!isWasmInitialized) {
9493 throw new Error("initializeWasm() must be awaited first!");
9495 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_free(_res);
9496 // debug statements here
9498 // uintptr_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg);
9500 export function CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg: number): number {
9501 if(!isWasmInitialized) {
9502 throw new Error("initializeWasm() must be awaited first!");
9504 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg);
9505 return nativeResponseValue;
9507 // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
9509 export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
9510 if(!isWasmInitialized) {
9511 throw new Error("initializeWasm() must be awaited first!");
9513 const nativeResponseValue = wasm.TS_CResult_ChannelInfoDecodeErrorZ_clone(orig);
9514 return nativeResponseValue;
9516 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
9518 export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
9519 if(!isWasmInitialized) {
9520 throw new Error("initializeWasm() must be awaited first!");
9522 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_ok(o);
9523 return nativeResponseValue;
9525 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
9527 export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
9528 if(!isWasmInitialized) {
9529 throw new Error("initializeWasm() must be awaited first!");
9531 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_err(e);
9532 return nativeResponseValue;
9534 // bool CResult_RoutingFeesDecodeErrorZ_is_ok(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR o);
9536 export function CResult_RoutingFeesDecodeErrorZ_is_ok(o: number): boolean {
9537 if(!isWasmInitialized) {
9538 throw new Error("initializeWasm() must be awaited first!");
9540 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_is_ok(o);
9541 return nativeResponseValue;
9543 // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
9545 export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
9546 if(!isWasmInitialized) {
9547 throw new Error("initializeWasm() must be awaited first!");
9549 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_free(_res);
9550 // debug statements here
9552 // uintptr_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg);
9554 export function CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg: number): number {
9555 if(!isWasmInitialized) {
9556 throw new Error("initializeWasm() must be awaited first!");
9558 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg);
9559 return nativeResponseValue;
9561 // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
9563 export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
9564 if(!isWasmInitialized) {
9565 throw new Error("initializeWasm() must be awaited first!");
9567 const nativeResponseValue = wasm.TS_CResult_RoutingFeesDecodeErrorZ_clone(orig);
9568 return nativeResponseValue;
9570 // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
9572 export function CVec_NetAddressZ_free(_res: number): void {
9573 if(!isWasmInitialized) {
9574 throw new Error("initializeWasm() must be awaited first!");
9576 const nativeResponseValue = wasm.TS_CVec_NetAddressZ_free(_res);
9577 // debug statements here
9579 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
9581 export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
9582 if(!isWasmInitialized) {
9583 throw new Error("initializeWasm() must be awaited first!");
9585 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
9586 return nativeResponseValue;
9588 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
9590 export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
9591 if(!isWasmInitialized) {
9592 throw new Error("initializeWasm() must be awaited first!");
9594 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
9595 return nativeResponseValue;
9597 // bool CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR o);
9599 export function CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o: number): boolean {
9600 if(!isWasmInitialized) {
9601 throw new Error("initializeWasm() must be awaited first!");
9603 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o);
9604 return nativeResponseValue;
9606 // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
9608 export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
9609 if(!isWasmInitialized) {
9610 throw new Error("initializeWasm() must be awaited first!");
9612 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
9613 // debug statements here
9615 // uintptr_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg);
9617 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg: number): number {
9618 if(!isWasmInitialized) {
9619 throw new Error("initializeWasm() must be awaited first!");
9621 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg);
9622 return nativeResponseValue;
9624 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
9626 export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
9627 if(!isWasmInitialized) {
9628 throw new Error("initializeWasm() must be awaited first!");
9630 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
9631 return nativeResponseValue;
9633 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_ok(struct LDKNodeAlias o);
9635 export function CResult_NodeAliasDecodeErrorZ_ok(o: number): number {
9636 if(!isWasmInitialized) {
9637 throw new Error("initializeWasm() must be awaited first!");
9639 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_ok(o);
9640 return nativeResponseValue;
9642 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_err(struct LDKDecodeError e);
9644 export function CResult_NodeAliasDecodeErrorZ_err(e: number): number {
9645 if(!isWasmInitialized) {
9646 throw new Error("initializeWasm() must be awaited first!");
9648 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_err(e);
9649 return nativeResponseValue;
9651 // bool CResult_NodeAliasDecodeErrorZ_is_ok(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR o);
9653 export function CResult_NodeAliasDecodeErrorZ_is_ok(o: number): boolean {
9654 if(!isWasmInitialized) {
9655 throw new Error("initializeWasm() must be awaited first!");
9657 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_is_ok(o);
9658 return nativeResponseValue;
9660 // void CResult_NodeAliasDecodeErrorZ_free(struct LDKCResult_NodeAliasDecodeErrorZ _res);
9662 export function CResult_NodeAliasDecodeErrorZ_free(_res: number): void {
9663 if(!isWasmInitialized) {
9664 throw new Error("initializeWasm() must be awaited first!");
9666 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_free(_res);
9667 // debug statements here
9669 // uintptr_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg);
9671 export function CResult_NodeAliasDecodeErrorZ_clone_ptr(arg: number): number {
9672 if(!isWasmInitialized) {
9673 throw new Error("initializeWasm() must be awaited first!");
9675 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(arg);
9676 return nativeResponseValue;
9678 // struct LDKCResult_NodeAliasDecodeErrorZ CResult_NodeAliasDecodeErrorZ_clone(const struct LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR orig);
9680 export function CResult_NodeAliasDecodeErrorZ_clone(orig: number): number {
9681 if(!isWasmInitialized) {
9682 throw new Error("initializeWasm() must be awaited first!");
9684 const nativeResponseValue = wasm.TS_CResult_NodeAliasDecodeErrorZ_clone(orig);
9685 return nativeResponseValue;
9687 // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
9689 export function CVec_u64Z_free(_res: number): void {
9690 if(!isWasmInitialized) {
9691 throw new Error("initializeWasm() must be awaited first!");
9693 const nativeResponseValue = wasm.TS_CVec_u64Z_free(_res);
9694 // debug statements here
9696 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
9698 export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
9699 if(!isWasmInitialized) {
9700 throw new Error("initializeWasm() must be awaited first!");
9702 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_ok(o);
9703 return nativeResponseValue;
9705 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
9707 export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
9708 if(!isWasmInitialized) {
9709 throw new Error("initializeWasm() must be awaited first!");
9711 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_err(e);
9712 return nativeResponseValue;
9714 // bool CResult_NodeInfoDecodeErrorZ_is_ok(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR o);
9716 export function CResult_NodeInfoDecodeErrorZ_is_ok(o: number): boolean {
9717 if(!isWasmInitialized) {
9718 throw new Error("initializeWasm() must be awaited first!");
9720 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_is_ok(o);
9721 return nativeResponseValue;
9723 // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
9725 export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
9726 if(!isWasmInitialized) {
9727 throw new Error("initializeWasm() must be awaited first!");
9729 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_free(_res);
9730 // debug statements here
9732 // uintptr_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg);
9734 export function CResult_NodeInfoDecodeErrorZ_clone_ptr(arg: number): number {
9735 if(!isWasmInitialized) {
9736 throw new Error("initializeWasm() must be awaited first!");
9738 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(arg);
9739 return nativeResponseValue;
9741 // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
9743 export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
9744 if(!isWasmInitialized) {
9745 throw new Error("initializeWasm() must be awaited first!");
9747 const nativeResponseValue = wasm.TS_CResult_NodeInfoDecodeErrorZ_clone(orig);
9748 return nativeResponseValue;
9750 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
9752 export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
9753 if(!isWasmInitialized) {
9754 throw new Error("initializeWasm() must be awaited first!");
9756 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_ok(o);
9757 return nativeResponseValue;
9759 // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
9761 export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
9762 if(!isWasmInitialized) {
9763 throw new Error("initializeWasm() must be awaited first!");
9765 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_err(e);
9766 return nativeResponseValue;
9768 // bool CResult_NetworkGraphDecodeErrorZ_is_ok(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR o);
9770 export function CResult_NetworkGraphDecodeErrorZ_is_ok(o: number): boolean {
9771 if(!isWasmInitialized) {
9772 throw new Error("initializeWasm() must be awaited first!");
9774 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_is_ok(o);
9775 return nativeResponseValue;
9777 // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
9779 export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
9780 if(!isWasmInitialized) {
9781 throw new Error("initializeWasm() must be awaited first!");
9783 const nativeResponseValue = wasm.TS_CResult_NetworkGraphDecodeErrorZ_free(_res);
9784 // debug statements here
9786 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_some(struct LDKCVec_NetAddressZ o);
9788 export function COption_CVec_NetAddressZZ_some(o: number): number {
9789 if(!isWasmInitialized) {
9790 throw new Error("initializeWasm() must be awaited first!");
9792 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_some(o);
9793 return nativeResponseValue;
9795 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_none(void);
9797 export function COption_CVec_NetAddressZZ_none(): number {
9798 if(!isWasmInitialized) {
9799 throw new Error("initializeWasm() must be awaited first!");
9801 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_none();
9802 return nativeResponseValue;
9804 // void COption_CVec_NetAddressZZ_free(struct LDKCOption_CVec_NetAddressZZ _res);
9806 export function COption_CVec_NetAddressZZ_free(_res: number): void {
9807 if(!isWasmInitialized) {
9808 throw new Error("initializeWasm() must be awaited first!");
9810 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_free(_res);
9811 // debug statements here
9813 // uintptr_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg);
9815 export function COption_CVec_NetAddressZZ_clone_ptr(arg: number): number {
9816 if(!isWasmInitialized) {
9817 throw new Error("initializeWasm() must be awaited first!");
9819 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone_ptr(arg);
9820 return nativeResponseValue;
9822 // struct LDKCOption_CVec_NetAddressZZ COption_CVec_NetAddressZZ_clone(const struct LDKCOption_CVec_NetAddressZZ *NONNULL_PTR orig);
9824 export function COption_CVec_NetAddressZZ_clone(orig: number): number {
9825 if(!isWasmInitialized) {
9826 throw new Error("initializeWasm() must be awaited first!");
9828 const nativeResponseValue = wasm.TS_COption_CVec_NetAddressZZ_clone(orig);
9829 return nativeResponseValue;
9831 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKDelayedPaymentOutputDescriptor o);
9833 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
9834 if(!isWasmInitialized) {
9835 throw new Error("initializeWasm() must be awaited first!");
9837 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o);
9838 return nativeResponseValue;
9840 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
9842 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
9843 if(!isWasmInitialized) {
9844 throw new Error("initializeWasm() must be awaited first!");
9846 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e);
9847 return nativeResponseValue;
9849 // bool CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
9851 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
9852 if(!isWasmInitialized) {
9853 throw new Error("initializeWasm() must be awaited first!");
9855 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
9856 return nativeResponseValue;
9858 // void CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res);
9860 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
9861 if(!isWasmInitialized) {
9862 throw new Error("initializeWasm() must be awaited first!");
9864 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res);
9865 // debug statements here
9867 // uintptr_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
9869 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
9870 if(!isWasmInitialized) {
9871 throw new Error("initializeWasm() must be awaited first!");
9873 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
9874 return nativeResponseValue;
9876 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
9878 export function CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
9879 if(!isWasmInitialized) {
9880 throw new Error("initializeWasm() must be awaited first!");
9882 const nativeResponseValue = wasm.TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig);
9883 return nativeResponseValue;
9885 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(struct LDKStaticPaymentOutputDescriptor o);
9887 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o: number): number {
9888 if(!isWasmInitialized) {
9889 throw new Error("initializeWasm() must be awaited first!");
9891 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o);
9892 return nativeResponseValue;
9894 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
9896 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e: number): number {
9897 if(!isWasmInitialized) {
9898 throw new Error("initializeWasm() must be awaited first!");
9900 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e);
9901 return nativeResponseValue;
9903 // bool CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
9905 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
9906 if(!isWasmInitialized) {
9907 throw new Error("initializeWasm() must be awaited first!");
9909 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o);
9910 return nativeResponseValue;
9912 // void CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res);
9914 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res: number): void {
9915 if(!isWasmInitialized) {
9916 throw new Error("initializeWasm() must be awaited first!");
9918 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res);
9919 // debug statements here
9921 // uintptr_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
9923 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
9924 if(!isWasmInitialized) {
9925 throw new Error("initializeWasm() must be awaited first!");
9927 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg);
9928 return nativeResponseValue;
9930 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
9932 export function CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig: number): number {
9933 if(!isWasmInitialized) {
9934 throw new Error("initializeWasm() must be awaited first!");
9936 const nativeResponseValue = wasm.TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig);
9937 return nativeResponseValue;
9939 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
9941 export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
9942 if(!isWasmInitialized) {
9943 throw new Error("initializeWasm() must be awaited first!");
9945 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
9946 return nativeResponseValue;
9948 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
9950 export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
9951 if(!isWasmInitialized) {
9952 throw new Error("initializeWasm() must be awaited first!");
9954 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
9955 return nativeResponseValue;
9957 // bool CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR o);
9959 export function CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o: number): boolean {
9960 if(!isWasmInitialized) {
9961 throw new Error("initializeWasm() must be awaited first!");
9963 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o);
9964 return nativeResponseValue;
9966 // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
9968 export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
9969 if(!isWasmInitialized) {
9970 throw new Error("initializeWasm() must be awaited first!");
9972 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
9973 // debug statements here
9975 // uintptr_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg);
9977 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg: number): number {
9978 if(!isWasmInitialized) {
9979 throw new Error("initializeWasm() must be awaited first!");
9981 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg);
9982 return nativeResponseValue;
9984 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
9986 export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
9987 if(!isWasmInitialized) {
9988 throw new Error("initializeWasm() must be awaited first!");
9990 const nativeResponseValue = wasm.TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
9991 return nativeResponseValue;
9993 // void CVec_PaymentPreimageZ_free(struct LDKCVec_PaymentPreimageZ _res);
9995 export function CVec_PaymentPreimageZ_free(_res: number): void {
9996 if(!isWasmInitialized) {
9997 throw new Error("initializeWasm() must be awaited first!");
9999 const nativeResponseValue = wasm.TS_CVec_PaymentPreimageZ_free(_res);
10000 // debug statements here
10002 // uintptr_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg);
10004 export function C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg: number): number {
10005 if(!isWasmInitialized) {
10006 throw new Error("initializeWasm() must be awaited first!");
10008 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg);
10009 return nativeResponseValue;
10011 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
10013 export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
10014 if(!isWasmInitialized) {
10015 throw new Error("initializeWasm() must be awaited first!");
10017 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
10018 return nativeResponseValue;
10020 // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
10022 export function C2Tuple_SignatureCVec_SignatureZZ_new(a: number, b: number): number {
10023 if(!isWasmInitialized) {
10024 throw new Error("initializeWasm() must be awaited first!");
10026 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_new(a, b);
10027 return nativeResponseValue;
10029 // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
10031 export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
10032 if(!isWasmInitialized) {
10033 throw new Error("initializeWasm() must be awaited first!");
10035 const nativeResponseValue = wasm.TS_C2Tuple_SignatureCVec_SignatureZZ_free(_res);
10036 // debug statements here
10038 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
10040 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
10041 if(!isWasmInitialized) {
10042 throw new Error("initializeWasm() must be awaited first!");
10044 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
10045 return nativeResponseValue;
10047 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
10049 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
10050 if(!isWasmInitialized) {
10051 throw new Error("initializeWasm() must be awaited first!");
10053 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
10054 return nativeResponseValue;
10056 // bool CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR o);
10058 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o: number): boolean {
10059 if(!isWasmInitialized) {
10060 throw new Error("initializeWasm() must be awaited first!");
10062 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o);
10063 return nativeResponseValue;
10065 // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
10067 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
10068 if(!isWasmInitialized) {
10069 throw new Error("initializeWasm() must be awaited first!");
10071 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
10072 // debug statements here
10074 // uintptr_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg);
10076 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg: number): number {
10077 if(!isWasmInitialized) {
10078 throw new Error("initializeWasm() must be awaited first!");
10080 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg);
10081 return nativeResponseValue;
10083 // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
10085 export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
10086 if(!isWasmInitialized) {
10087 throw new Error("initializeWasm() must be awaited first!");
10089 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
10090 return nativeResponseValue;
10092 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
10094 export function CResult_SignatureNoneZ_ok(o: number): number {
10095 if(!isWasmInitialized) {
10096 throw new Error("initializeWasm() must be awaited first!");
10098 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_ok(o);
10099 return nativeResponseValue;
10101 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
10103 export function CResult_SignatureNoneZ_err(): number {
10104 if(!isWasmInitialized) {
10105 throw new Error("initializeWasm() must be awaited first!");
10107 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_err();
10108 return nativeResponseValue;
10110 // bool CResult_SignatureNoneZ_is_ok(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR o);
10112 export function CResult_SignatureNoneZ_is_ok(o: number): boolean {
10113 if(!isWasmInitialized) {
10114 throw new Error("initializeWasm() must be awaited first!");
10116 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_is_ok(o);
10117 return nativeResponseValue;
10119 // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
10121 export function CResult_SignatureNoneZ_free(_res: number): void {
10122 if(!isWasmInitialized) {
10123 throw new Error("initializeWasm() must be awaited first!");
10125 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_free(_res);
10126 // debug statements here
10128 // uintptr_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg);
10130 export function CResult_SignatureNoneZ_clone_ptr(arg: number): number {
10131 if(!isWasmInitialized) {
10132 throw new Error("initializeWasm() must be awaited first!");
10134 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone_ptr(arg);
10135 return nativeResponseValue;
10137 // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
10139 export function CResult_SignatureNoneZ_clone(orig: number): number {
10140 if(!isWasmInitialized) {
10141 throw new Error("initializeWasm() must be awaited first!");
10143 const nativeResponseValue = wasm.TS_CResult_SignatureNoneZ_clone(orig);
10144 return nativeResponseValue;
10146 // uintptr_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg);
10148 export function C2Tuple_SignatureSignatureZ_clone_ptr(arg: number): number {
10149 if(!isWasmInitialized) {
10150 throw new Error("initializeWasm() must be awaited first!");
10152 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone_ptr(arg);
10153 return nativeResponseValue;
10155 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_clone(const struct LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR orig);
10157 export function C2Tuple_SignatureSignatureZ_clone(orig: number): number {
10158 if(!isWasmInitialized) {
10159 throw new Error("initializeWasm() must be awaited first!");
10161 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_clone(orig);
10162 return nativeResponseValue;
10164 // struct LDKC2Tuple_SignatureSignatureZ C2Tuple_SignatureSignatureZ_new(struct LDKSignature a, struct LDKSignature b);
10166 export function C2Tuple_SignatureSignatureZ_new(a: number, b: number): number {
10167 if(!isWasmInitialized) {
10168 throw new Error("initializeWasm() must be awaited first!");
10170 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_new(a, b);
10171 return nativeResponseValue;
10173 // void C2Tuple_SignatureSignatureZ_free(struct LDKC2Tuple_SignatureSignatureZ _res);
10175 export function C2Tuple_SignatureSignatureZ_free(_res: number): void {
10176 if(!isWasmInitialized) {
10177 throw new Error("initializeWasm() must be awaited first!");
10179 const nativeResponseValue = wasm.TS_C2Tuple_SignatureSignatureZ_free(_res);
10180 // debug statements here
10182 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_ok(struct LDKC2Tuple_SignatureSignatureZ o);
10184 export function CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o: number): number {
10185 if(!isWasmInitialized) {
10186 throw new Error("initializeWasm() must be awaited first!");
10188 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o);
10189 return nativeResponseValue;
10191 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_err(void);
10193 export function CResult_C2Tuple_SignatureSignatureZNoneZ_err(): number {
10194 if(!isWasmInitialized) {
10195 throw new Error("initializeWasm() must be awaited first!");
10197 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err();
10198 return nativeResponseValue;
10200 // bool CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR o);
10202 export function CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o: number): boolean {
10203 if(!isWasmInitialized) {
10204 throw new Error("initializeWasm() must be awaited first!");
10206 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o);
10207 return nativeResponseValue;
10209 // void CResult_C2Tuple_SignatureSignatureZNoneZ_free(struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res);
10211 export function CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res: number): void {
10212 if(!isWasmInitialized) {
10213 throw new Error("initializeWasm() must be awaited first!");
10215 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res);
10216 // debug statements here
10218 // uintptr_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg);
10220 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg: number): number {
10221 if(!isWasmInitialized) {
10222 throw new Error("initializeWasm() must be awaited first!");
10224 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg);
10225 return nativeResponseValue;
10227 // struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ CResult_C2Tuple_SignatureSignatureZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR orig);
10229 export function CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig: number): number {
10230 if(!isWasmInitialized) {
10231 throw new Error("initializeWasm() must be awaited first!");
10233 const nativeResponseValue = wasm.TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig);
10234 return nativeResponseValue;
10236 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_ok(struct LDKSecretKey o);
10238 export function CResult_SecretKeyNoneZ_ok(o: number): number {
10239 if(!isWasmInitialized) {
10240 throw new Error("initializeWasm() must be awaited first!");
10242 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_ok(o);
10243 return nativeResponseValue;
10245 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_err(void);
10247 export function CResult_SecretKeyNoneZ_err(): number {
10248 if(!isWasmInitialized) {
10249 throw new Error("initializeWasm() must be awaited first!");
10251 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_err();
10252 return nativeResponseValue;
10254 // bool CResult_SecretKeyNoneZ_is_ok(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR o);
10256 export function CResult_SecretKeyNoneZ_is_ok(o: number): boolean {
10257 if(!isWasmInitialized) {
10258 throw new Error("initializeWasm() must be awaited first!");
10260 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_is_ok(o);
10261 return nativeResponseValue;
10263 // void CResult_SecretKeyNoneZ_free(struct LDKCResult_SecretKeyNoneZ _res);
10265 export function CResult_SecretKeyNoneZ_free(_res: number): void {
10266 if(!isWasmInitialized) {
10267 throw new Error("initializeWasm() must be awaited first!");
10269 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_free(_res);
10270 // debug statements here
10272 // uintptr_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg);
10274 export function CResult_SecretKeyNoneZ_clone_ptr(arg: number): number {
10275 if(!isWasmInitialized) {
10276 throw new Error("initializeWasm() must be awaited first!");
10278 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone_ptr(arg);
10279 return nativeResponseValue;
10281 // struct LDKCResult_SecretKeyNoneZ CResult_SecretKeyNoneZ_clone(const struct LDKCResult_SecretKeyNoneZ *NONNULL_PTR orig);
10283 export function CResult_SecretKeyNoneZ_clone(orig: number): number {
10284 if(!isWasmInitialized) {
10285 throw new Error("initializeWasm() must be awaited first!");
10287 const nativeResponseValue = wasm.TS_CResult_SecretKeyNoneZ_clone(orig);
10288 return nativeResponseValue;
10290 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
10292 export function CResult_SignDecodeErrorZ_ok(o: number): number {
10293 if(!isWasmInitialized) {
10294 throw new Error("initializeWasm() must be awaited first!");
10296 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_ok(o);
10297 return nativeResponseValue;
10299 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
10301 export function CResult_SignDecodeErrorZ_err(e: number): number {
10302 if(!isWasmInitialized) {
10303 throw new Error("initializeWasm() must be awaited first!");
10305 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_err(e);
10306 return nativeResponseValue;
10308 // bool CResult_SignDecodeErrorZ_is_ok(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR o);
10310 export function CResult_SignDecodeErrorZ_is_ok(o: number): boolean {
10311 if(!isWasmInitialized) {
10312 throw new Error("initializeWasm() must be awaited first!");
10314 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_is_ok(o);
10315 return nativeResponseValue;
10317 // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
10319 export function CResult_SignDecodeErrorZ_free(_res: number): void {
10320 if(!isWasmInitialized) {
10321 throw new Error("initializeWasm() must be awaited first!");
10323 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_free(_res);
10324 // debug statements here
10326 // uintptr_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg);
10328 export function CResult_SignDecodeErrorZ_clone_ptr(arg: number): number {
10329 if(!isWasmInitialized) {
10330 throw new Error("initializeWasm() must be awaited first!");
10332 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone_ptr(arg);
10333 return nativeResponseValue;
10335 // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
10337 export function CResult_SignDecodeErrorZ_clone(orig: number): number {
10338 if(!isWasmInitialized) {
10339 throw new Error("initializeWasm() must be awaited first!");
10341 const nativeResponseValue = wasm.TS_CResult_SignDecodeErrorZ_clone(orig);
10342 return nativeResponseValue;
10344 // void CVec_u5Z_free(struct LDKCVec_u5Z _res);
10346 export function CVec_u5Z_free(_res: number): void {
10347 if(!isWasmInitialized) {
10348 throw new Error("initializeWasm() must be awaited first!");
10350 const nativeResponseValue = wasm.TS_CVec_u5Z_free(_res);
10351 // debug statements here
10353 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_ok(struct LDKRecoverableSignature o);
10355 export function CResult_RecoverableSignatureNoneZ_ok(o: number): number {
10356 if(!isWasmInitialized) {
10357 throw new Error("initializeWasm() must be awaited first!");
10359 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_ok(o);
10360 return nativeResponseValue;
10362 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_err(void);
10364 export function CResult_RecoverableSignatureNoneZ_err(): number {
10365 if(!isWasmInitialized) {
10366 throw new Error("initializeWasm() must be awaited first!");
10368 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_err();
10369 return nativeResponseValue;
10371 // bool CResult_RecoverableSignatureNoneZ_is_ok(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR o);
10373 export function CResult_RecoverableSignatureNoneZ_is_ok(o: number): boolean {
10374 if(!isWasmInitialized) {
10375 throw new Error("initializeWasm() must be awaited first!");
10377 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_is_ok(o);
10378 return nativeResponseValue;
10380 // void CResult_RecoverableSignatureNoneZ_free(struct LDKCResult_RecoverableSignatureNoneZ _res);
10382 export function CResult_RecoverableSignatureNoneZ_free(_res: number): void {
10383 if(!isWasmInitialized) {
10384 throw new Error("initializeWasm() must be awaited first!");
10386 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_free(_res);
10387 // debug statements here
10389 // uintptr_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg);
10391 export function CResult_RecoverableSignatureNoneZ_clone_ptr(arg: number): number {
10392 if(!isWasmInitialized) {
10393 throw new Error("initializeWasm() must be awaited first!");
10395 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone_ptr(arg);
10396 return nativeResponseValue;
10398 // struct LDKCResult_RecoverableSignatureNoneZ CResult_RecoverableSignatureNoneZ_clone(const struct LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR orig);
10400 export function CResult_RecoverableSignatureNoneZ_clone(orig: number): number {
10401 if(!isWasmInitialized) {
10402 throw new Error("initializeWasm() must be awaited first!");
10404 const nativeResponseValue = wasm.TS_CResult_RecoverableSignatureNoneZ_clone(orig);
10405 return nativeResponseValue;
10407 // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
10409 export function CVec_u8Z_free(_res: number): void {
10410 if(!isWasmInitialized) {
10411 throw new Error("initializeWasm() must be awaited first!");
10413 const nativeResponseValue = wasm.TS_CVec_u8Z_free(_res);
10414 // debug statements here
10416 // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
10418 export function CVec_CVec_u8ZZ_free(_res: number): void {
10419 if(!isWasmInitialized) {
10420 throw new Error("initializeWasm() must be awaited first!");
10422 const nativeResponseValue = wasm.TS_CVec_CVec_u8ZZ_free(_res);
10423 // debug statements here
10425 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
10427 export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: number): number {
10428 if(!isWasmInitialized) {
10429 throw new Error("initializeWasm() must be awaited first!");
10431 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_ok(o);
10432 return nativeResponseValue;
10434 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
10436 export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
10437 if(!isWasmInitialized) {
10438 throw new Error("initializeWasm() must be awaited first!");
10440 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_err();
10441 return nativeResponseValue;
10443 // bool CResult_CVec_CVec_u8ZZNoneZ_is_ok(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR o);
10445 export function CResult_CVec_CVec_u8ZZNoneZ_is_ok(o: number): boolean {
10446 if(!isWasmInitialized) {
10447 throw new Error("initializeWasm() must be awaited first!");
10449 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(o);
10450 return nativeResponseValue;
10452 // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
10454 export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
10455 if(!isWasmInitialized) {
10456 throw new Error("initializeWasm() must be awaited first!");
10458 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_free(_res);
10459 // debug statements here
10461 // uintptr_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg);
10463 export function CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg: number): number {
10464 if(!isWasmInitialized) {
10465 throw new Error("initializeWasm() must be awaited first!");
10467 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg);
10468 return nativeResponseValue;
10470 // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
10472 export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
10473 if(!isWasmInitialized) {
10474 throw new Error("initializeWasm() must be awaited first!");
10476 const nativeResponseValue = wasm.TS_CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
10477 return nativeResponseValue;
10479 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
10481 export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
10482 if(!isWasmInitialized) {
10483 throw new Error("initializeWasm() must be awaited first!");
10485 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_ok(o);
10486 return nativeResponseValue;
10488 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
10490 export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
10491 if(!isWasmInitialized) {
10492 throw new Error("initializeWasm() must be awaited first!");
10494 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_err(e);
10495 return nativeResponseValue;
10497 // bool CResult_InMemorySignerDecodeErrorZ_is_ok(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR o);
10499 export function CResult_InMemorySignerDecodeErrorZ_is_ok(o: number): boolean {
10500 if(!isWasmInitialized) {
10501 throw new Error("initializeWasm() must be awaited first!");
10503 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_is_ok(o);
10504 return nativeResponseValue;
10506 // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
10508 export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
10509 if(!isWasmInitialized) {
10510 throw new Error("initializeWasm() must be awaited first!");
10512 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_free(_res);
10513 // debug statements here
10515 // uintptr_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg);
10517 export function CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg: number): number {
10518 if(!isWasmInitialized) {
10519 throw new Error("initializeWasm() must be awaited first!");
10521 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg);
10522 return nativeResponseValue;
10524 // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
10526 export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
10527 if(!isWasmInitialized) {
10528 throw new Error("initializeWasm() must be awaited first!");
10530 const nativeResponseValue = wasm.TS_CResult_InMemorySignerDecodeErrorZ_clone(orig);
10531 return nativeResponseValue;
10533 // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
10535 export function CVec_TxOutZ_free(_res: number): void {
10536 if(!isWasmInitialized) {
10537 throw new Error("initializeWasm() must be awaited first!");
10539 const nativeResponseValue = wasm.TS_CVec_TxOutZ_free(_res);
10540 // debug statements here
10542 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
10544 export function CResult_TransactionNoneZ_ok(o: number): number {
10545 if(!isWasmInitialized) {
10546 throw new Error("initializeWasm() must be awaited first!");
10548 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_ok(o);
10549 return nativeResponseValue;
10551 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
10553 export function CResult_TransactionNoneZ_err(): number {
10554 if(!isWasmInitialized) {
10555 throw new Error("initializeWasm() must be awaited first!");
10557 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_err();
10558 return nativeResponseValue;
10560 // bool CResult_TransactionNoneZ_is_ok(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR o);
10562 export function CResult_TransactionNoneZ_is_ok(o: number): boolean {
10563 if(!isWasmInitialized) {
10564 throw new Error("initializeWasm() must be awaited first!");
10566 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_is_ok(o);
10567 return nativeResponseValue;
10569 // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
10571 export function CResult_TransactionNoneZ_free(_res: number): void {
10572 if(!isWasmInitialized) {
10573 throw new Error("initializeWasm() must be awaited first!");
10575 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_free(_res);
10576 // debug statements here
10578 // uintptr_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg);
10580 export function CResult_TransactionNoneZ_clone_ptr(arg: number): number {
10581 if(!isWasmInitialized) {
10582 throw new Error("initializeWasm() must be awaited first!");
10584 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone_ptr(arg);
10585 return nativeResponseValue;
10587 // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_clone(const struct LDKCResult_TransactionNoneZ *NONNULL_PTR orig);
10589 export function CResult_TransactionNoneZ_clone(orig: number): number {
10590 if(!isWasmInitialized) {
10591 throw new Error("initializeWasm() must be awaited first!");
10593 const nativeResponseValue = wasm.TS_CResult_TransactionNoneZ_clone(orig);
10594 return nativeResponseValue;
10596 // struct LDKCOption_u16Z COption_u16Z_some(uint16_t o);
10598 export function COption_u16Z_some(o: number): number {
10599 if(!isWasmInitialized) {
10600 throw new Error("initializeWasm() must be awaited first!");
10602 const nativeResponseValue = wasm.TS_COption_u16Z_some(o);
10603 return nativeResponseValue;
10605 // struct LDKCOption_u16Z COption_u16Z_none(void);
10607 export function COption_u16Z_none(): number {
10608 if(!isWasmInitialized) {
10609 throw new Error("initializeWasm() must be awaited first!");
10611 const nativeResponseValue = wasm.TS_COption_u16Z_none();
10612 return nativeResponseValue;
10614 // void COption_u16Z_free(struct LDKCOption_u16Z _res);
10616 export function COption_u16Z_free(_res: number): void {
10617 if(!isWasmInitialized) {
10618 throw new Error("initializeWasm() must be awaited first!");
10620 const nativeResponseValue = wasm.TS_COption_u16Z_free(_res);
10621 // debug statements here
10623 // uintptr_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg);
10625 export function COption_u16Z_clone_ptr(arg: number): number {
10626 if(!isWasmInitialized) {
10627 throw new Error("initializeWasm() must be awaited first!");
10629 const nativeResponseValue = wasm.TS_COption_u16Z_clone_ptr(arg);
10630 return nativeResponseValue;
10632 // struct LDKCOption_u16Z COption_u16Z_clone(const struct LDKCOption_u16Z *NONNULL_PTR orig);
10634 export function COption_u16Z_clone(orig: number): number {
10635 if(!isWasmInitialized) {
10636 throw new Error("initializeWasm() must be awaited first!");
10638 const nativeResponseValue = wasm.TS_COption_u16Z_clone(orig);
10639 return nativeResponseValue;
10641 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
10643 export function CResult_NoneAPIErrorZ_ok(): number {
10644 if(!isWasmInitialized) {
10645 throw new Error("initializeWasm() must be awaited first!");
10647 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_ok();
10648 return nativeResponseValue;
10650 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
10652 export function CResult_NoneAPIErrorZ_err(e: number): number {
10653 if(!isWasmInitialized) {
10654 throw new Error("initializeWasm() must be awaited first!");
10656 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_err(e);
10657 return nativeResponseValue;
10659 // bool CResult_NoneAPIErrorZ_is_ok(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR o);
10661 export function CResult_NoneAPIErrorZ_is_ok(o: number): boolean {
10662 if(!isWasmInitialized) {
10663 throw new Error("initializeWasm() must be awaited first!");
10665 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_is_ok(o);
10666 return nativeResponseValue;
10668 // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
10670 export function CResult_NoneAPIErrorZ_free(_res: number): void {
10671 if(!isWasmInitialized) {
10672 throw new Error("initializeWasm() must be awaited first!");
10674 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_free(_res);
10675 // debug statements here
10677 // uintptr_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg);
10679 export function CResult_NoneAPIErrorZ_clone_ptr(arg: number): number {
10680 if(!isWasmInitialized) {
10681 throw new Error("initializeWasm() must be awaited first!");
10683 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone_ptr(arg);
10684 return nativeResponseValue;
10686 // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
10688 export function CResult_NoneAPIErrorZ_clone(orig: number): number {
10689 if(!isWasmInitialized) {
10690 throw new Error("initializeWasm() must be awaited first!");
10692 const nativeResponseValue = wasm.TS_CResult_NoneAPIErrorZ_clone(orig);
10693 return nativeResponseValue;
10695 // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
10697 export function CVec_CResult_NoneAPIErrorZZ_free(_res: number): void {
10698 if(!isWasmInitialized) {
10699 throw new Error("initializeWasm() must be awaited first!");
10701 const nativeResponseValue = wasm.TS_CVec_CResult_NoneAPIErrorZZ_free(_res);
10702 // debug statements here
10704 // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
10706 export function CVec_APIErrorZ_free(_res: number): void {
10707 if(!isWasmInitialized) {
10708 throw new Error("initializeWasm() must be awaited first!");
10710 const nativeResponseValue = wasm.TS_CVec_APIErrorZ_free(_res);
10711 // debug statements here
10713 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_ok(struct LDKThirtyTwoBytes o);
10715 export function CResult__u832APIErrorZ_ok(o: number): number {
10716 if(!isWasmInitialized) {
10717 throw new Error("initializeWasm() must be awaited first!");
10719 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_ok(o);
10720 return nativeResponseValue;
10722 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_err(struct LDKAPIError e);
10724 export function CResult__u832APIErrorZ_err(e: number): number {
10725 if(!isWasmInitialized) {
10726 throw new Error("initializeWasm() must be awaited first!");
10728 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_err(e);
10729 return nativeResponseValue;
10731 // bool CResult__u832APIErrorZ_is_ok(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR o);
10733 export function CResult__u832APIErrorZ_is_ok(o: number): boolean {
10734 if(!isWasmInitialized) {
10735 throw new Error("initializeWasm() must be awaited first!");
10737 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_is_ok(o);
10738 return nativeResponseValue;
10740 // void CResult__u832APIErrorZ_free(struct LDKCResult__u832APIErrorZ _res);
10742 export function CResult__u832APIErrorZ_free(_res: number): void {
10743 if(!isWasmInitialized) {
10744 throw new Error("initializeWasm() must be awaited first!");
10746 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_free(_res);
10747 // debug statements here
10749 // uintptr_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg);
10751 export function CResult__u832APIErrorZ_clone_ptr(arg: number): number {
10752 if(!isWasmInitialized) {
10753 throw new Error("initializeWasm() must be awaited first!");
10755 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone_ptr(arg);
10756 return nativeResponseValue;
10758 // struct LDKCResult__u832APIErrorZ CResult__u832APIErrorZ_clone(const struct LDKCResult__u832APIErrorZ *NONNULL_PTR orig);
10760 export function CResult__u832APIErrorZ_clone(orig: number): number {
10761 if(!isWasmInitialized) {
10762 throw new Error("initializeWasm() must be awaited first!");
10764 const nativeResponseValue = wasm.TS_CResult__u832APIErrorZ_clone(orig);
10765 return nativeResponseValue;
10767 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_ok(struct LDKThirtyTwoBytes o);
10769 export function CResult_PaymentIdPaymentSendFailureZ_ok(o: number): number {
10770 if(!isWasmInitialized) {
10771 throw new Error("initializeWasm() must be awaited first!");
10773 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_ok(o);
10774 return nativeResponseValue;
10776 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
10778 export function CResult_PaymentIdPaymentSendFailureZ_err(e: number): number {
10779 if(!isWasmInitialized) {
10780 throw new Error("initializeWasm() must be awaited first!");
10782 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_err(e);
10783 return nativeResponseValue;
10785 // bool CResult_PaymentIdPaymentSendFailureZ_is_ok(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR o);
10787 export function CResult_PaymentIdPaymentSendFailureZ_is_ok(o: number): boolean {
10788 if(!isWasmInitialized) {
10789 throw new Error("initializeWasm() must be awaited first!");
10791 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(o);
10792 return nativeResponseValue;
10794 // void CResult_PaymentIdPaymentSendFailureZ_free(struct LDKCResult_PaymentIdPaymentSendFailureZ _res);
10796 export function CResult_PaymentIdPaymentSendFailureZ_free(_res: number): void {
10797 if(!isWasmInitialized) {
10798 throw new Error("initializeWasm() must be awaited first!");
10800 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_free(_res);
10801 // debug statements here
10803 // uintptr_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg);
10805 export function CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg: number): number {
10806 if(!isWasmInitialized) {
10807 throw new Error("initializeWasm() must be awaited first!");
10809 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg);
10810 return nativeResponseValue;
10812 // struct LDKCResult_PaymentIdPaymentSendFailureZ CResult_PaymentIdPaymentSendFailureZ_clone(const struct LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR orig);
10814 export function CResult_PaymentIdPaymentSendFailureZ_clone(orig: number): number {
10815 if(!isWasmInitialized) {
10816 throw new Error("initializeWasm() must be awaited first!");
10818 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentSendFailureZ_clone(orig);
10819 return nativeResponseValue;
10821 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
10823 export function CResult_NonePaymentSendFailureZ_ok(): number {
10824 if(!isWasmInitialized) {
10825 throw new Error("initializeWasm() must be awaited first!");
10827 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_ok();
10828 return nativeResponseValue;
10830 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
10832 export function CResult_NonePaymentSendFailureZ_err(e: number): number {
10833 if(!isWasmInitialized) {
10834 throw new Error("initializeWasm() must be awaited first!");
10836 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_err(e);
10837 return nativeResponseValue;
10839 // bool CResult_NonePaymentSendFailureZ_is_ok(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR o);
10841 export function CResult_NonePaymentSendFailureZ_is_ok(o: number): boolean {
10842 if(!isWasmInitialized) {
10843 throw new Error("initializeWasm() must be awaited first!");
10845 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_is_ok(o);
10846 return nativeResponseValue;
10848 // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
10850 export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
10851 if(!isWasmInitialized) {
10852 throw new Error("initializeWasm() must be awaited first!");
10854 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_free(_res);
10855 // debug statements here
10857 // uintptr_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg);
10859 export function CResult_NonePaymentSendFailureZ_clone_ptr(arg: number): number {
10860 if(!isWasmInitialized) {
10861 throw new Error("initializeWasm() must be awaited first!");
10863 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone_ptr(arg);
10864 return nativeResponseValue;
10866 // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
10868 export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
10869 if(!isWasmInitialized) {
10870 throw new Error("initializeWasm() must be awaited first!");
10872 const nativeResponseValue = wasm.TS_CResult_NonePaymentSendFailureZ_clone(orig);
10873 return nativeResponseValue;
10875 // uintptr_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg);
10877 export function C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg: number): number {
10878 if(!isWasmInitialized) {
10879 throw new Error("initializeWasm() must be awaited first!");
10881 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg);
10882 return nativeResponseValue;
10884 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_clone(const struct LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR orig);
10886 export function C2Tuple_PaymentHashPaymentIdZ_clone(orig: number): number {
10887 if(!isWasmInitialized) {
10888 throw new Error("initializeWasm() must be awaited first!");
10890 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_clone(orig);
10891 return nativeResponseValue;
10893 // struct LDKC2Tuple_PaymentHashPaymentIdZ C2Tuple_PaymentHashPaymentIdZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
10895 export function C2Tuple_PaymentHashPaymentIdZ_new(a: number, b: number): number {
10896 if(!isWasmInitialized) {
10897 throw new Error("initializeWasm() must be awaited first!");
10899 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_new(a, b);
10900 return nativeResponseValue;
10902 // void C2Tuple_PaymentHashPaymentIdZ_free(struct LDKC2Tuple_PaymentHashPaymentIdZ _res);
10904 export function C2Tuple_PaymentHashPaymentIdZ_free(_res: number): void {
10905 if(!isWasmInitialized) {
10906 throw new Error("initializeWasm() must be awaited first!");
10908 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentIdZ_free(_res);
10909 // debug statements here
10911 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(struct LDKC2Tuple_PaymentHashPaymentIdZ o);
10913 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o: number): number {
10914 if(!isWasmInitialized) {
10915 throw new Error("initializeWasm() must be awaited first!");
10917 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o);
10918 return nativeResponseValue;
10920 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
10922 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e: number): number {
10923 if(!isWasmInitialized) {
10924 throw new Error("initializeWasm() must be awaited first!");
10926 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e);
10927 return nativeResponseValue;
10929 // bool CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR o);
10931 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o: number): boolean {
10932 if(!isWasmInitialized) {
10933 throw new Error("initializeWasm() must be awaited first!");
10935 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o);
10936 return nativeResponseValue;
10938 // void CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res);
10940 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res: number): void {
10941 if(!isWasmInitialized) {
10942 throw new Error("initializeWasm() must be awaited first!");
10944 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res);
10945 // debug statements here
10947 // uintptr_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg);
10949 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg: number): number {
10950 if(!isWasmInitialized) {
10951 throw new Error("initializeWasm() must be awaited first!");
10953 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg);
10954 return nativeResponseValue;
10956 // struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR orig);
10958 export function CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig: number): number {
10959 if(!isWasmInitialized) {
10960 throw new Error("initializeWasm() must be awaited first!");
10962 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig);
10963 return nativeResponseValue;
10965 // void CVec_ThirtyTwoBytesZ_free(struct LDKCVec_ThirtyTwoBytesZ _res);
10967 export function CVec_ThirtyTwoBytesZ_free(_res: number): void {
10968 if(!isWasmInitialized) {
10969 throw new Error("initializeWasm() must be awaited first!");
10971 const nativeResponseValue = wasm.TS_CVec_ThirtyTwoBytesZ_free(_res);
10972 // debug statements here
10974 // uintptr_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg);
10976 export function C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg: number): number {
10977 if(!isWasmInitialized) {
10978 throw new Error("initializeWasm() must be awaited first!");
10980 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg);
10981 return nativeResponseValue;
10983 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_clone(const struct LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR orig);
10985 export function C2Tuple_PaymentHashPaymentSecretZ_clone(orig: number): number {
10986 if(!isWasmInitialized) {
10987 throw new Error("initializeWasm() must be awaited first!");
10989 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_clone(orig);
10990 return nativeResponseValue;
10992 // struct LDKC2Tuple_PaymentHashPaymentSecretZ C2Tuple_PaymentHashPaymentSecretZ_new(struct LDKThirtyTwoBytes a, struct LDKThirtyTwoBytes b);
10994 export function C2Tuple_PaymentHashPaymentSecretZ_new(a: number, b: number): number {
10995 if(!isWasmInitialized) {
10996 throw new Error("initializeWasm() must be awaited first!");
10998 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_new(a, b);
10999 return nativeResponseValue;
11001 // void C2Tuple_PaymentHashPaymentSecretZ_free(struct LDKC2Tuple_PaymentHashPaymentSecretZ _res);
11003 export function C2Tuple_PaymentHashPaymentSecretZ_free(_res: number): void {
11004 if(!isWasmInitialized) {
11005 throw new Error("initializeWasm() must be awaited first!");
11007 const nativeResponseValue = wasm.TS_C2Tuple_PaymentHashPaymentSecretZ_free(_res);
11008 // debug statements here
11010 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11012 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o: number): number {
11013 if(!isWasmInitialized) {
11014 throw new Error("initializeWasm() must be awaited first!");
11016 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o);
11017 return nativeResponseValue;
11019 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(void);
11021 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err(): number {
11022 if(!isWasmInitialized) {
11023 throw new Error("initializeWasm() must be awaited first!");
11025 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
11026 return nativeResponseValue;
11028 // bool CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR o);
11030 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o: number): boolean {
11031 if(!isWasmInitialized) {
11032 throw new Error("initializeWasm() must be awaited first!");
11034 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o);
11035 return nativeResponseValue;
11037 // void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res);
11039 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res: number): void {
11040 if(!isWasmInitialized) {
11041 throw new Error("initializeWasm() must be awaited first!");
11043 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res);
11044 // debug statements here
11046 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg);
11048 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg: number): number {
11049 if(!isWasmInitialized) {
11050 throw new Error("initializeWasm() must be awaited first!");
11052 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg);
11053 return nativeResponseValue;
11055 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR orig);
11057 export function CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig: number): number {
11058 if(!isWasmInitialized) {
11059 throw new Error("initializeWasm() must be awaited first!");
11061 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig);
11062 return nativeResponseValue;
11064 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(struct LDKC2Tuple_PaymentHashPaymentSecretZ o);
11066 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o: number): number {
11067 if(!isWasmInitialized) {
11068 throw new Error("initializeWasm() must be awaited first!");
11070 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o);
11071 return nativeResponseValue;
11073 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(struct LDKAPIError e);
11075 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e: number): number {
11076 if(!isWasmInitialized) {
11077 throw new Error("initializeWasm() must be awaited first!");
11079 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e);
11080 return nativeResponseValue;
11082 // bool CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR o);
11084 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o: number): boolean {
11085 if(!isWasmInitialized) {
11086 throw new Error("initializeWasm() must be awaited first!");
11088 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o);
11089 return nativeResponseValue;
11091 // void CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res);
11093 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res: number): void {
11094 if(!isWasmInitialized) {
11095 throw new Error("initializeWasm() must be awaited first!");
11097 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res);
11098 // debug statements here
11100 // uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg);
11102 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg: number): number {
11103 if(!isWasmInitialized) {
11104 throw new Error("initializeWasm() must be awaited first!");
11106 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg);
11107 return nativeResponseValue;
11109 // struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(const struct LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR orig);
11111 export function CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig: number): number {
11112 if(!isWasmInitialized) {
11113 throw new Error("initializeWasm() must be awaited first!");
11115 const nativeResponseValue = wasm.TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig);
11116 return nativeResponseValue;
11118 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_ok(struct LDKThirtyTwoBytes o);
11120 export function CResult_PaymentSecretNoneZ_ok(o: number): number {
11121 if(!isWasmInitialized) {
11122 throw new Error("initializeWasm() must be awaited first!");
11124 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_ok(o);
11125 return nativeResponseValue;
11127 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_err(void);
11129 export function CResult_PaymentSecretNoneZ_err(): number {
11130 if(!isWasmInitialized) {
11131 throw new Error("initializeWasm() must be awaited first!");
11133 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_err();
11134 return nativeResponseValue;
11136 // bool CResult_PaymentSecretNoneZ_is_ok(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR o);
11138 export function CResult_PaymentSecretNoneZ_is_ok(o: number): boolean {
11139 if(!isWasmInitialized) {
11140 throw new Error("initializeWasm() must be awaited first!");
11142 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_is_ok(o);
11143 return nativeResponseValue;
11145 // void CResult_PaymentSecretNoneZ_free(struct LDKCResult_PaymentSecretNoneZ _res);
11147 export function CResult_PaymentSecretNoneZ_free(_res: number): void {
11148 if(!isWasmInitialized) {
11149 throw new Error("initializeWasm() must be awaited first!");
11151 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_free(_res);
11152 // debug statements here
11154 // uintptr_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg);
11156 export function CResult_PaymentSecretNoneZ_clone_ptr(arg: number): number {
11157 if(!isWasmInitialized) {
11158 throw new Error("initializeWasm() must be awaited first!");
11160 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone_ptr(arg);
11161 return nativeResponseValue;
11163 // struct LDKCResult_PaymentSecretNoneZ CResult_PaymentSecretNoneZ_clone(const struct LDKCResult_PaymentSecretNoneZ *NONNULL_PTR orig);
11165 export function CResult_PaymentSecretNoneZ_clone(orig: number): number {
11166 if(!isWasmInitialized) {
11167 throw new Error("initializeWasm() must be awaited first!");
11169 const nativeResponseValue = wasm.TS_CResult_PaymentSecretNoneZ_clone(orig);
11170 return nativeResponseValue;
11172 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
11174 export function CResult_PaymentSecretAPIErrorZ_ok(o: number): number {
11175 if(!isWasmInitialized) {
11176 throw new Error("initializeWasm() must be awaited first!");
11178 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_ok(o);
11179 return nativeResponseValue;
11181 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_err(struct LDKAPIError e);
11183 export function CResult_PaymentSecretAPIErrorZ_err(e: number): number {
11184 if(!isWasmInitialized) {
11185 throw new Error("initializeWasm() must be awaited first!");
11187 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_err(e);
11188 return nativeResponseValue;
11190 // bool CResult_PaymentSecretAPIErrorZ_is_ok(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR o);
11192 export function CResult_PaymentSecretAPIErrorZ_is_ok(o: number): boolean {
11193 if(!isWasmInitialized) {
11194 throw new Error("initializeWasm() must be awaited first!");
11196 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_is_ok(o);
11197 return nativeResponseValue;
11199 // void CResult_PaymentSecretAPIErrorZ_free(struct LDKCResult_PaymentSecretAPIErrorZ _res);
11201 export function CResult_PaymentSecretAPIErrorZ_free(_res: number): void {
11202 if(!isWasmInitialized) {
11203 throw new Error("initializeWasm() must be awaited first!");
11205 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_free(_res);
11206 // debug statements here
11208 // uintptr_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg);
11210 export function CResult_PaymentSecretAPIErrorZ_clone_ptr(arg: number): number {
11211 if(!isWasmInitialized) {
11212 throw new Error("initializeWasm() must be awaited first!");
11214 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(arg);
11215 return nativeResponseValue;
11217 // struct LDKCResult_PaymentSecretAPIErrorZ CResult_PaymentSecretAPIErrorZ_clone(const struct LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR orig);
11219 export function CResult_PaymentSecretAPIErrorZ_clone(orig: number): number {
11220 if(!isWasmInitialized) {
11221 throw new Error("initializeWasm() must be awaited first!");
11223 const nativeResponseValue = wasm.TS_CResult_PaymentSecretAPIErrorZ_clone(orig);
11224 return nativeResponseValue;
11226 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_ok(struct LDKThirtyTwoBytes o);
11228 export function CResult_PaymentPreimageAPIErrorZ_ok(o: number): number {
11229 if(!isWasmInitialized) {
11230 throw new Error("initializeWasm() must be awaited first!");
11232 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_ok(o);
11233 return nativeResponseValue;
11235 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_err(struct LDKAPIError e);
11237 export function CResult_PaymentPreimageAPIErrorZ_err(e: number): number {
11238 if(!isWasmInitialized) {
11239 throw new Error("initializeWasm() must be awaited first!");
11241 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_err(e);
11242 return nativeResponseValue;
11244 // bool CResult_PaymentPreimageAPIErrorZ_is_ok(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR o);
11246 export function CResult_PaymentPreimageAPIErrorZ_is_ok(o: number): boolean {
11247 if(!isWasmInitialized) {
11248 throw new Error("initializeWasm() must be awaited first!");
11250 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_is_ok(o);
11251 return nativeResponseValue;
11253 // void CResult_PaymentPreimageAPIErrorZ_free(struct LDKCResult_PaymentPreimageAPIErrorZ _res);
11255 export function CResult_PaymentPreimageAPIErrorZ_free(_res: number): void {
11256 if(!isWasmInitialized) {
11257 throw new Error("initializeWasm() must be awaited first!");
11259 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_free(_res);
11260 // debug statements here
11262 // uintptr_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg);
11264 export function CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg: number): number {
11265 if(!isWasmInitialized) {
11266 throw new Error("initializeWasm() must be awaited first!");
11268 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg);
11269 return nativeResponseValue;
11271 // struct LDKCResult_PaymentPreimageAPIErrorZ CResult_PaymentPreimageAPIErrorZ_clone(const struct LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR orig);
11273 export function CResult_PaymentPreimageAPIErrorZ_clone(orig: number): number {
11274 if(!isWasmInitialized) {
11275 throw new Error("initializeWasm() must be awaited first!");
11277 const nativeResponseValue = wasm.TS_CResult_PaymentPreimageAPIErrorZ_clone(orig);
11278 return nativeResponseValue;
11280 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(struct LDKCounterpartyForwardingInfo o);
11282 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o: number): number {
11283 if(!isWasmInitialized) {
11284 throw new Error("initializeWasm() must be awaited first!");
11286 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o);
11287 return nativeResponseValue;
11289 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_err(struct LDKDecodeError e);
11291 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e: number): number {
11292 if(!isWasmInitialized) {
11293 throw new Error("initializeWasm() must be awaited first!");
11295 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e);
11296 return nativeResponseValue;
11298 // bool CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR o);
11300 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o: number): boolean {
11301 if(!isWasmInitialized) {
11302 throw new Error("initializeWasm() must be awaited first!");
11304 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o);
11305 return nativeResponseValue;
11307 // void CResult_CounterpartyForwardingInfoDecodeErrorZ_free(struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res);
11309 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res: number): void {
11310 if(!isWasmInitialized) {
11311 throw new Error("initializeWasm() must be awaited first!");
11313 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res);
11314 // debug statements here
11316 // uintptr_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg);
11318 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg: number): number {
11319 if(!isWasmInitialized) {
11320 throw new Error("initializeWasm() must be awaited first!");
11322 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg);
11323 return nativeResponseValue;
11325 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(const struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR orig);
11327 export function CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig: number): number {
11328 if(!isWasmInitialized) {
11329 throw new Error("initializeWasm() must be awaited first!");
11331 const nativeResponseValue = wasm.TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig);
11332 return nativeResponseValue;
11334 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_ok(struct LDKChannelCounterparty o);
11336 export function CResult_ChannelCounterpartyDecodeErrorZ_ok(o: number): number {
11337 if(!isWasmInitialized) {
11338 throw new Error("initializeWasm() must be awaited first!");
11340 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(o);
11341 return nativeResponseValue;
11343 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_err(struct LDKDecodeError e);
11345 export function CResult_ChannelCounterpartyDecodeErrorZ_err(e: number): number {
11346 if(!isWasmInitialized) {
11347 throw new Error("initializeWasm() must be awaited first!");
11349 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_err(e);
11350 return nativeResponseValue;
11352 // bool CResult_ChannelCounterpartyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR o);
11354 export function CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o: number): boolean {
11355 if(!isWasmInitialized) {
11356 throw new Error("initializeWasm() must be awaited first!");
11358 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o);
11359 return nativeResponseValue;
11361 // void CResult_ChannelCounterpartyDecodeErrorZ_free(struct LDKCResult_ChannelCounterpartyDecodeErrorZ _res);
11363 export function CResult_ChannelCounterpartyDecodeErrorZ_free(_res: number): void {
11364 if(!isWasmInitialized) {
11365 throw new Error("initializeWasm() must be awaited first!");
11367 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_free(_res);
11368 // debug statements here
11370 // uintptr_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg);
11372 export function CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg: number): number {
11373 if(!isWasmInitialized) {
11374 throw new Error("initializeWasm() must be awaited first!");
11376 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg);
11377 return nativeResponseValue;
11379 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ CResult_ChannelCounterpartyDecodeErrorZ_clone(const struct LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR orig);
11381 export function CResult_ChannelCounterpartyDecodeErrorZ_clone(orig: number): number {
11382 if(!isWasmInitialized) {
11383 throw new Error("initializeWasm() must be awaited first!");
11385 const nativeResponseValue = wasm.TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(orig);
11386 return nativeResponseValue;
11388 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_ok(struct LDKChannelDetails o);
11390 export function CResult_ChannelDetailsDecodeErrorZ_ok(o: number): number {
11391 if(!isWasmInitialized) {
11392 throw new Error("initializeWasm() must be awaited first!");
11394 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_ok(o);
11395 return nativeResponseValue;
11397 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_err(struct LDKDecodeError e);
11399 export function CResult_ChannelDetailsDecodeErrorZ_err(e: number): number {
11400 if(!isWasmInitialized) {
11401 throw new Error("initializeWasm() must be awaited first!");
11403 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_err(e);
11404 return nativeResponseValue;
11406 // bool CResult_ChannelDetailsDecodeErrorZ_is_ok(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR o);
11408 export function CResult_ChannelDetailsDecodeErrorZ_is_ok(o: number): boolean {
11409 if(!isWasmInitialized) {
11410 throw new Error("initializeWasm() must be awaited first!");
11412 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(o);
11413 return nativeResponseValue;
11415 // void CResult_ChannelDetailsDecodeErrorZ_free(struct LDKCResult_ChannelDetailsDecodeErrorZ _res);
11417 export function CResult_ChannelDetailsDecodeErrorZ_free(_res: number): void {
11418 if(!isWasmInitialized) {
11419 throw new Error("initializeWasm() must be awaited first!");
11421 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_free(_res);
11422 // debug statements here
11424 // uintptr_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg);
11426 export function CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg: number): number {
11427 if(!isWasmInitialized) {
11428 throw new Error("initializeWasm() must be awaited first!");
11430 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg);
11431 return nativeResponseValue;
11433 // struct LDKCResult_ChannelDetailsDecodeErrorZ CResult_ChannelDetailsDecodeErrorZ_clone(const struct LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR orig);
11435 export function CResult_ChannelDetailsDecodeErrorZ_clone(orig: number): number {
11436 if(!isWasmInitialized) {
11437 throw new Error("initializeWasm() must be awaited first!");
11439 const nativeResponseValue = wasm.TS_CResult_ChannelDetailsDecodeErrorZ_clone(orig);
11440 return nativeResponseValue;
11442 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_ok(struct LDKPhantomRouteHints o);
11444 export function CResult_PhantomRouteHintsDecodeErrorZ_ok(o: number): number {
11445 if(!isWasmInitialized) {
11446 throw new Error("initializeWasm() must be awaited first!");
11448 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(o);
11449 return nativeResponseValue;
11451 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_err(struct LDKDecodeError e);
11453 export function CResult_PhantomRouteHintsDecodeErrorZ_err(e: number): number {
11454 if(!isWasmInitialized) {
11455 throw new Error("initializeWasm() must be awaited first!");
11457 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_err(e);
11458 return nativeResponseValue;
11460 // bool CResult_PhantomRouteHintsDecodeErrorZ_is_ok(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR o);
11462 export function CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o: number): boolean {
11463 if(!isWasmInitialized) {
11464 throw new Error("initializeWasm() must be awaited first!");
11466 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o);
11467 return nativeResponseValue;
11469 // void CResult_PhantomRouteHintsDecodeErrorZ_free(struct LDKCResult_PhantomRouteHintsDecodeErrorZ _res);
11471 export function CResult_PhantomRouteHintsDecodeErrorZ_free(_res: number): void {
11472 if(!isWasmInitialized) {
11473 throw new Error("initializeWasm() must be awaited first!");
11475 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_free(_res);
11476 // debug statements here
11478 // uintptr_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg);
11480 export function CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg: number): number {
11481 if(!isWasmInitialized) {
11482 throw new Error("initializeWasm() must be awaited first!");
11484 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg);
11485 return nativeResponseValue;
11487 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ CResult_PhantomRouteHintsDecodeErrorZ_clone(const struct LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR orig);
11489 export function CResult_PhantomRouteHintsDecodeErrorZ_clone(orig: number): number {
11490 if(!isWasmInitialized) {
11491 throw new Error("initializeWasm() must be awaited first!");
11493 const nativeResponseValue = wasm.TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(orig);
11494 return nativeResponseValue;
11496 // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
11498 export function CVec_ChannelMonitorZ_free(_res: number): void {
11499 if(!isWasmInitialized) {
11500 throw new Error("initializeWasm() must be awaited first!");
11502 const nativeResponseValue = wasm.TS_CVec_ChannelMonitorZ_free(_res);
11503 // debug statements here
11505 // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
11507 export function C2Tuple_BlockHashChannelManagerZ_new(a: number, b: number): number {
11508 if(!isWasmInitialized) {
11509 throw new Error("initializeWasm() must be awaited first!");
11511 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_new(a, b);
11512 return nativeResponseValue;
11514 // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
11516 export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
11517 if(!isWasmInitialized) {
11518 throw new Error("initializeWasm() must be awaited first!");
11520 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_free(_res);
11521 // debug statements here
11523 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
11525 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
11526 if(!isWasmInitialized) {
11527 throw new Error("initializeWasm() must be awaited first!");
11529 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
11530 return nativeResponseValue;
11532 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
11534 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
11535 if(!isWasmInitialized) {
11536 throw new Error("initializeWasm() must be awaited first!");
11538 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
11539 return nativeResponseValue;
11541 // bool CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR o);
11543 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o: number): boolean {
11544 if(!isWasmInitialized) {
11545 throw new Error("initializeWasm() must be awaited first!");
11547 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o);
11548 return nativeResponseValue;
11550 // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
11552 export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
11553 if(!isWasmInitialized) {
11554 throw new Error("initializeWasm() must be awaited first!");
11556 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
11557 // debug statements here
11559 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
11561 export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
11562 if(!isWasmInitialized) {
11563 throw new Error("initializeWasm() must be awaited first!");
11565 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_ok(o);
11566 return nativeResponseValue;
11568 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
11570 export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
11571 if(!isWasmInitialized) {
11572 throw new Error("initializeWasm() must be awaited first!");
11574 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_err(e);
11575 return nativeResponseValue;
11577 // bool CResult_ChannelConfigDecodeErrorZ_is_ok(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR o);
11579 export function CResult_ChannelConfigDecodeErrorZ_is_ok(o: number): boolean {
11580 if(!isWasmInitialized) {
11581 throw new Error("initializeWasm() must be awaited first!");
11583 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_is_ok(o);
11584 return nativeResponseValue;
11586 // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
11588 export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
11589 if(!isWasmInitialized) {
11590 throw new Error("initializeWasm() must be awaited first!");
11592 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_free(_res);
11593 // debug statements here
11595 // uintptr_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg);
11597 export function CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg: number): number {
11598 if(!isWasmInitialized) {
11599 throw new Error("initializeWasm() must be awaited first!");
11601 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg);
11602 return nativeResponseValue;
11604 // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
11606 export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
11607 if(!isWasmInitialized) {
11608 throw new Error("initializeWasm() must be awaited first!");
11610 const nativeResponseValue = wasm.TS_CResult_ChannelConfigDecodeErrorZ_clone(orig);
11611 return nativeResponseValue;
11613 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
11615 export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
11616 if(!isWasmInitialized) {
11617 throw new Error("initializeWasm() must be awaited first!");
11619 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_ok(o);
11620 return nativeResponseValue;
11622 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
11624 export function CResult_OutPointDecodeErrorZ_err(e: number): number {
11625 if(!isWasmInitialized) {
11626 throw new Error("initializeWasm() must be awaited first!");
11628 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_err(e);
11629 return nativeResponseValue;
11631 // bool CResult_OutPointDecodeErrorZ_is_ok(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR o);
11633 export function CResult_OutPointDecodeErrorZ_is_ok(o: number): boolean {
11634 if(!isWasmInitialized) {
11635 throw new Error("initializeWasm() must be awaited first!");
11637 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_is_ok(o);
11638 return nativeResponseValue;
11640 // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
11642 export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
11643 if(!isWasmInitialized) {
11644 throw new Error("initializeWasm() must be awaited first!");
11646 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_free(_res);
11647 // debug statements here
11649 // uintptr_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg);
11651 export function CResult_OutPointDecodeErrorZ_clone_ptr(arg: number): number {
11652 if(!isWasmInitialized) {
11653 throw new Error("initializeWasm() must be awaited first!");
11655 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone_ptr(arg);
11656 return nativeResponseValue;
11658 // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
11660 export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
11661 if(!isWasmInitialized) {
11662 throw new Error("initializeWasm() must be awaited first!");
11664 const nativeResponseValue = wasm.TS_CResult_OutPointDecodeErrorZ_clone(orig);
11665 return nativeResponseValue;
11667 // struct LDKCOption_TypeZ COption_TypeZ_some(struct LDKType o);
11669 export function COption_TypeZ_some(o: number): number {
11670 if(!isWasmInitialized) {
11671 throw new Error("initializeWasm() must be awaited first!");
11673 const nativeResponseValue = wasm.TS_COption_TypeZ_some(o);
11674 return nativeResponseValue;
11676 // struct LDKCOption_TypeZ COption_TypeZ_none(void);
11678 export function COption_TypeZ_none(): number {
11679 if(!isWasmInitialized) {
11680 throw new Error("initializeWasm() must be awaited first!");
11682 const nativeResponseValue = wasm.TS_COption_TypeZ_none();
11683 return nativeResponseValue;
11685 // void COption_TypeZ_free(struct LDKCOption_TypeZ _res);
11687 export function COption_TypeZ_free(_res: number): void {
11688 if(!isWasmInitialized) {
11689 throw new Error("initializeWasm() must be awaited first!");
11691 const nativeResponseValue = wasm.TS_COption_TypeZ_free(_res);
11692 // debug statements here
11694 // uintptr_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg);
11696 export function COption_TypeZ_clone_ptr(arg: number): number {
11697 if(!isWasmInitialized) {
11698 throw new Error("initializeWasm() must be awaited first!");
11700 const nativeResponseValue = wasm.TS_COption_TypeZ_clone_ptr(arg);
11701 return nativeResponseValue;
11703 // struct LDKCOption_TypeZ COption_TypeZ_clone(const struct LDKCOption_TypeZ *NONNULL_PTR orig);
11705 export function COption_TypeZ_clone(orig: number): number {
11706 if(!isWasmInitialized) {
11707 throw new Error("initializeWasm() must be awaited first!");
11709 const nativeResponseValue = wasm.TS_COption_TypeZ_clone(orig);
11710 return nativeResponseValue;
11712 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_ok(struct LDKCOption_TypeZ o);
11714 export function CResult_COption_TypeZDecodeErrorZ_ok(o: number): number {
11715 if(!isWasmInitialized) {
11716 throw new Error("initializeWasm() must be awaited first!");
11718 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_ok(o);
11719 return nativeResponseValue;
11721 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_err(struct LDKDecodeError e);
11723 export function CResult_COption_TypeZDecodeErrorZ_err(e: number): number {
11724 if(!isWasmInitialized) {
11725 throw new Error("initializeWasm() must be awaited first!");
11727 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_err(e);
11728 return nativeResponseValue;
11730 // bool CResult_COption_TypeZDecodeErrorZ_is_ok(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR o);
11732 export function CResult_COption_TypeZDecodeErrorZ_is_ok(o: number): boolean {
11733 if(!isWasmInitialized) {
11734 throw new Error("initializeWasm() must be awaited first!");
11736 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_is_ok(o);
11737 return nativeResponseValue;
11739 // void CResult_COption_TypeZDecodeErrorZ_free(struct LDKCResult_COption_TypeZDecodeErrorZ _res);
11741 export function CResult_COption_TypeZDecodeErrorZ_free(_res: number): void {
11742 if(!isWasmInitialized) {
11743 throw new Error("initializeWasm() must be awaited first!");
11745 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_free(_res);
11746 // debug statements here
11748 // uintptr_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg);
11750 export function CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg: number): number {
11751 if(!isWasmInitialized) {
11752 throw new Error("initializeWasm() must be awaited first!");
11754 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg);
11755 return nativeResponseValue;
11757 // struct LDKCResult_COption_TypeZDecodeErrorZ CResult_COption_TypeZDecodeErrorZ_clone(const struct LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR orig);
11759 export function CResult_COption_TypeZDecodeErrorZ_clone(orig: number): number {
11760 if(!isWasmInitialized) {
11761 throw new Error("initializeWasm() must be awaited first!");
11763 const nativeResponseValue = wasm.TS_CResult_COption_TypeZDecodeErrorZ_clone(orig);
11764 return nativeResponseValue;
11766 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_ok(struct LDKThirtyTwoBytes o);
11768 export function CResult_PaymentIdPaymentErrorZ_ok(o: number): number {
11769 if(!isWasmInitialized) {
11770 throw new Error("initializeWasm() must be awaited first!");
11772 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_ok(o);
11773 return nativeResponseValue;
11775 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_err(struct LDKPaymentError e);
11777 export function CResult_PaymentIdPaymentErrorZ_err(e: number): number {
11778 if(!isWasmInitialized) {
11779 throw new Error("initializeWasm() must be awaited first!");
11781 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_err(e);
11782 return nativeResponseValue;
11784 // bool CResult_PaymentIdPaymentErrorZ_is_ok(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR o);
11786 export function CResult_PaymentIdPaymentErrorZ_is_ok(o: number): boolean {
11787 if(!isWasmInitialized) {
11788 throw new Error("initializeWasm() must be awaited first!");
11790 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_is_ok(o);
11791 return nativeResponseValue;
11793 // void CResult_PaymentIdPaymentErrorZ_free(struct LDKCResult_PaymentIdPaymentErrorZ _res);
11795 export function CResult_PaymentIdPaymentErrorZ_free(_res: number): void {
11796 if(!isWasmInitialized) {
11797 throw new Error("initializeWasm() must be awaited first!");
11799 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_free(_res);
11800 // debug statements here
11802 // uintptr_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg);
11804 export function CResult_PaymentIdPaymentErrorZ_clone_ptr(arg: number): number {
11805 if(!isWasmInitialized) {
11806 throw new Error("initializeWasm() must be awaited first!");
11808 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(arg);
11809 return nativeResponseValue;
11811 // struct LDKCResult_PaymentIdPaymentErrorZ CResult_PaymentIdPaymentErrorZ_clone(const struct LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR orig);
11813 export function CResult_PaymentIdPaymentErrorZ_clone(orig: number): number {
11814 if(!isWasmInitialized) {
11815 throw new Error("initializeWasm() must be awaited first!");
11817 const nativeResponseValue = wasm.TS_CResult_PaymentIdPaymentErrorZ_clone(orig);
11818 return nativeResponseValue;
11820 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_ok(enum LDKSiPrefix o);
11822 export function CResult_SiPrefixParseErrorZ_ok(o: SiPrefix): number {
11823 if(!isWasmInitialized) {
11824 throw new Error("initializeWasm() must be awaited first!");
11826 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_ok(o);
11827 return nativeResponseValue;
11829 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_err(struct LDKParseError e);
11831 export function CResult_SiPrefixParseErrorZ_err(e: number): number {
11832 if(!isWasmInitialized) {
11833 throw new Error("initializeWasm() must be awaited first!");
11835 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_err(e);
11836 return nativeResponseValue;
11838 // bool CResult_SiPrefixParseErrorZ_is_ok(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR o);
11840 export function CResult_SiPrefixParseErrorZ_is_ok(o: number): boolean {
11841 if(!isWasmInitialized) {
11842 throw new Error("initializeWasm() must be awaited first!");
11844 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_is_ok(o);
11845 return nativeResponseValue;
11847 // void CResult_SiPrefixParseErrorZ_free(struct LDKCResult_SiPrefixParseErrorZ _res);
11849 export function CResult_SiPrefixParseErrorZ_free(_res: number): void {
11850 if(!isWasmInitialized) {
11851 throw new Error("initializeWasm() must be awaited first!");
11853 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_free(_res);
11854 // debug statements here
11856 // uintptr_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg);
11858 export function CResult_SiPrefixParseErrorZ_clone_ptr(arg: number): number {
11859 if(!isWasmInitialized) {
11860 throw new Error("initializeWasm() must be awaited first!");
11862 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone_ptr(arg);
11863 return nativeResponseValue;
11865 // struct LDKCResult_SiPrefixParseErrorZ CResult_SiPrefixParseErrorZ_clone(const struct LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR orig);
11867 export function CResult_SiPrefixParseErrorZ_clone(orig: number): number {
11868 if(!isWasmInitialized) {
11869 throw new Error("initializeWasm() must be awaited first!");
11871 const nativeResponseValue = wasm.TS_CResult_SiPrefixParseErrorZ_clone(orig);
11872 return nativeResponseValue;
11874 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_ok(struct LDKInvoice o);
11876 export function CResult_InvoiceParseOrSemanticErrorZ_ok(o: number): number {
11877 if(!isWasmInitialized) {
11878 throw new Error("initializeWasm() must be awaited first!");
11880 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_ok(o);
11881 return nativeResponseValue;
11883 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_err(struct LDKParseOrSemanticError e);
11885 export function CResult_InvoiceParseOrSemanticErrorZ_err(e: number): number {
11886 if(!isWasmInitialized) {
11887 throw new Error("initializeWasm() must be awaited first!");
11889 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_err(e);
11890 return nativeResponseValue;
11892 // bool CResult_InvoiceParseOrSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR o);
11894 export function CResult_InvoiceParseOrSemanticErrorZ_is_ok(o: number): boolean {
11895 if(!isWasmInitialized) {
11896 throw new Error("initializeWasm() must be awaited first!");
11898 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(o);
11899 return nativeResponseValue;
11901 // void CResult_InvoiceParseOrSemanticErrorZ_free(struct LDKCResult_InvoiceParseOrSemanticErrorZ _res);
11903 export function CResult_InvoiceParseOrSemanticErrorZ_free(_res: number): void {
11904 if(!isWasmInitialized) {
11905 throw new Error("initializeWasm() must be awaited first!");
11907 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_free(_res);
11908 // debug statements here
11910 // uintptr_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg);
11912 export function CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg: number): number {
11913 if(!isWasmInitialized) {
11914 throw new Error("initializeWasm() must be awaited first!");
11916 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg);
11917 return nativeResponseValue;
11919 // struct LDKCResult_InvoiceParseOrSemanticErrorZ CResult_InvoiceParseOrSemanticErrorZ_clone(const struct LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR orig);
11921 export function CResult_InvoiceParseOrSemanticErrorZ_clone(orig: number): number {
11922 if(!isWasmInitialized) {
11923 throw new Error("initializeWasm() must be awaited first!");
11925 const nativeResponseValue = wasm.TS_CResult_InvoiceParseOrSemanticErrorZ_clone(orig);
11926 return nativeResponseValue;
11928 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_ok(struct LDKSignedRawInvoice o);
11930 export function CResult_SignedRawInvoiceParseErrorZ_ok(o: number): number {
11931 if(!isWasmInitialized) {
11932 throw new Error("initializeWasm() must be awaited first!");
11934 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_ok(o);
11935 return nativeResponseValue;
11937 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_err(struct LDKParseError e);
11939 export function CResult_SignedRawInvoiceParseErrorZ_err(e: number): number {
11940 if(!isWasmInitialized) {
11941 throw new Error("initializeWasm() must be awaited first!");
11943 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_err(e);
11944 return nativeResponseValue;
11946 // bool CResult_SignedRawInvoiceParseErrorZ_is_ok(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR o);
11948 export function CResult_SignedRawInvoiceParseErrorZ_is_ok(o: number): boolean {
11949 if(!isWasmInitialized) {
11950 throw new Error("initializeWasm() must be awaited first!");
11952 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(o);
11953 return nativeResponseValue;
11955 // void CResult_SignedRawInvoiceParseErrorZ_free(struct LDKCResult_SignedRawInvoiceParseErrorZ _res);
11957 export function CResult_SignedRawInvoiceParseErrorZ_free(_res: number): void {
11958 if(!isWasmInitialized) {
11959 throw new Error("initializeWasm() must be awaited first!");
11961 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_free(_res);
11962 // debug statements here
11964 // uintptr_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg);
11966 export function CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg: number): number {
11967 if(!isWasmInitialized) {
11968 throw new Error("initializeWasm() must be awaited first!");
11970 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg);
11971 return nativeResponseValue;
11973 // struct LDKCResult_SignedRawInvoiceParseErrorZ CResult_SignedRawInvoiceParseErrorZ_clone(const struct LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR orig);
11975 export function CResult_SignedRawInvoiceParseErrorZ_clone(orig: number): number {
11976 if(!isWasmInitialized) {
11977 throw new Error("initializeWasm() must be awaited first!");
11979 const nativeResponseValue = wasm.TS_CResult_SignedRawInvoiceParseErrorZ_clone(orig);
11980 return nativeResponseValue;
11982 // uintptr_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg);
11984 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg: number): number {
11985 if(!isWasmInitialized) {
11986 throw new Error("initializeWasm() must be awaited first!");
11988 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg);
11989 return nativeResponseValue;
11991 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(const struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR orig);
11993 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig: number): number {
11994 if(!isWasmInitialized) {
11995 throw new Error("initializeWasm() must be awaited first!");
11997 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig);
11998 return nativeResponseValue;
12000 // struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(struct LDKRawInvoice a, struct LDKThirtyTwoBytes b, struct LDKInvoiceSignature c);
12002 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a: number, b: number, c: number): number {
12003 if(!isWasmInitialized) {
12004 throw new Error("initializeWasm() must be awaited first!");
12006 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a, b, c);
12007 return nativeResponseValue;
12009 // void C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res);
12011 export function C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res: number): void {
12012 if(!isWasmInitialized) {
12013 throw new Error("initializeWasm() must be awaited first!");
12015 const nativeResponseValue = wasm.TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res);
12016 // debug statements here
12018 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_ok(struct LDKPayeePubKey o);
12020 export function CResult_PayeePubKeyErrorZ_ok(o: number): number {
12021 if(!isWasmInitialized) {
12022 throw new Error("initializeWasm() must be awaited first!");
12024 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_ok(o);
12025 return nativeResponseValue;
12027 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_err(enum LDKSecp256k1Error e);
12029 export function CResult_PayeePubKeyErrorZ_err(e: Secp256k1Error): number {
12030 if(!isWasmInitialized) {
12031 throw new Error("initializeWasm() must be awaited first!");
12033 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_err(e);
12034 return nativeResponseValue;
12036 // bool CResult_PayeePubKeyErrorZ_is_ok(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR o);
12038 export function CResult_PayeePubKeyErrorZ_is_ok(o: number): boolean {
12039 if(!isWasmInitialized) {
12040 throw new Error("initializeWasm() must be awaited first!");
12042 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_is_ok(o);
12043 return nativeResponseValue;
12045 // void CResult_PayeePubKeyErrorZ_free(struct LDKCResult_PayeePubKeyErrorZ _res);
12047 export function CResult_PayeePubKeyErrorZ_free(_res: number): void {
12048 if(!isWasmInitialized) {
12049 throw new Error("initializeWasm() must be awaited first!");
12051 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_free(_res);
12052 // debug statements here
12054 // uintptr_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg);
12056 export function CResult_PayeePubKeyErrorZ_clone_ptr(arg: number): number {
12057 if(!isWasmInitialized) {
12058 throw new Error("initializeWasm() must be awaited first!");
12060 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone_ptr(arg);
12061 return nativeResponseValue;
12063 // struct LDKCResult_PayeePubKeyErrorZ CResult_PayeePubKeyErrorZ_clone(const struct LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR orig);
12065 export function CResult_PayeePubKeyErrorZ_clone(orig: number): number {
12066 if(!isWasmInitialized) {
12067 throw new Error("initializeWasm() must be awaited first!");
12069 const nativeResponseValue = wasm.TS_CResult_PayeePubKeyErrorZ_clone(orig);
12070 return nativeResponseValue;
12072 // void CVec_PrivateRouteZ_free(struct LDKCVec_PrivateRouteZ _res);
12074 export function CVec_PrivateRouteZ_free(_res: number): void {
12075 if(!isWasmInitialized) {
12076 throw new Error("initializeWasm() must be awaited first!");
12078 const nativeResponseValue = wasm.TS_CVec_PrivateRouteZ_free(_res);
12079 // debug statements here
12081 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_ok(struct LDKPositiveTimestamp o);
12083 export function CResult_PositiveTimestampCreationErrorZ_ok(o: number): number {
12084 if(!isWasmInitialized) {
12085 throw new Error("initializeWasm() must be awaited first!");
12087 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_ok(o);
12088 return nativeResponseValue;
12090 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_err(enum LDKCreationError e);
12092 export function CResult_PositiveTimestampCreationErrorZ_err(e: CreationError): number {
12093 if(!isWasmInitialized) {
12094 throw new Error("initializeWasm() must be awaited first!");
12096 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_err(e);
12097 return nativeResponseValue;
12099 // bool CResult_PositiveTimestampCreationErrorZ_is_ok(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR o);
12101 export function CResult_PositiveTimestampCreationErrorZ_is_ok(o: number): boolean {
12102 if(!isWasmInitialized) {
12103 throw new Error("initializeWasm() must be awaited first!");
12105 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_is_ok(o);
12106 return nativeResponseValue;
12108 // void CResult_PositiveTimestampCreationErrorZ_free(struct LDKCResult_PositiveTimestampCreationErrorZ _res);
12110 export function CResult_PositiveTimestampCreationErrorZ_free(_res: number): void {
12111 if(!isWasmInitialized) {
12112 throw new Error("initializeWasm() must be awaited first!");
12114 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_free(_res);
12115 // debug statements here
12117 // uintptr_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg);
12119 export function CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg: number): number {
12120 if(!isWasmInitialized) {
12121 throw new Error("initializeWasm() must be awaited first!");
12123 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg);
12124 return nativeResponseValue;
12126 // struct LDKCResult_PositiveTimestampCreationErrorZ CResult_PositiveTimestampCreationErrorZ_clone(const struct LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR orig);
12128 export function CResult_PositiveTimestampCreationErrorZ_clone(orig: number): number {
12129 if(!isWasmInitialized) {
12130 throw new Error("initializeWasm() must be awaited first!");
12132 const nativeResponseValue = wasm.TS_CResult_PositiveTimestampCreationErrorZ_clone(orig);
12133 return nativeResponseValue;
12135 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_ok(void);
12137 export function CResult_NoneSemanticErrorZ_ok(): number {
12138 if(!isWasmInitialized) {
12139 throw new Error("initializeWasm() must be awaited first!");
12141 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_ok();
12142 return nativeResponseValue;
12144 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_err(enum LDKSemanticError e);
12146 export function CResult_NoneSemanticErrorZ_err(e: SemanticError): number {
12147 if(!isWasmInitialized) {
12148 throw new Error("initializeWasm() must be awaited first!");
12150 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_err(e);
12151 return nativeResponseValue;
12153 // bool CResult_NoneSemanticErrorZ_is_ok(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR o);
12155 export function CResult_NoneSemanticErrorZ_is_ok(o: number): boolean {
12156 if(!isWasmInitialized) {
12157 throw new Error("initializeWasm() must be awaited first!");
12159 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_is_ok(o);
12160 return nativeResponseValue;
12162 // void CResult_NoneSemanticErrorZ_free(struct LDKCResult_NoneSemanticErrorZ _res);
12164 export function CResult_NoneSemanticErrorZ_free(_res: number): void {
12165 if(!isWasmInitialized) {
12166 throw new Error("initializeWasm() must be awaited first!");
12168 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_free(_res);
12169 // debug statements here
12171 // uintptr_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg);
12173 export function CResult_NoneSemanticErrorZ_clone_ptr(arg: number): number {
12174 if(!isWasmInitialized) {
12175 throw new Error("initializeWasm() must be awaited first!");
12177 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone_ptr(arg);
12178 return nativeResponseValue;
12180 // struct LDKCResult_NoneSemanticErrorZ CResult_NoneSemanticErrorZ_clone(const struct LDKCResult_NoneSemanticErrorZ *NONNULL_PTR orig);
12182 export function CResult_NoneSemanticErrorZ_clone(orig: number): number {
12183 if(!isWasmInitialized) {
12184 throw new Error("initializeWasm() must be awaited first!");
12186 const nativeResponseValue = wasm.TS_CResult_NoneSemanticErrorZ_clone(orig);
12187 return nativeResponseValue;
12189 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_ok(struct LDKInvoice o);
12191 export function CResult_InvoiceSemanticErrorZ_ok(o: number): number {
12192 if(!isWasmInitialized) {
12193 throw new Error("initializeWasm() must be awaited first!");
12195 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_ok(o);
12196 return nativeResponseValue;
12198 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_err(enum LDKSemanticError e);
12200 export function CResult_InvoiceSemanticErrorZ_err(e: SemanticError): number {
12201 if(!isWasmInitialized) {
12202 throw new Error("initializeWasm() must be awaited first!");
12204 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_err(e);
12205 return nativeResponseValue;
12207 // bool CResult_InvoiceSemanticErrorZ_is_ok(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR o);
12209 export function CResult_InvoiceSemanticErrorZ_is_ok(o: number): boolean {
12210 if(!isWasmInitialized) {
12211 throw new Error("initializeWasm() must be awaited first!");
12213 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_is_ok(o);
12214 return nativeResponseValue;
12216 // void CResult_InvoiceSemanticErrorZ_free(struct LDKCResult_InvoiceSemanticErrorZ _res);
12218 export function CResult_InvoiceSemanticErrorZ_free(_res: number): void {
12219 if(!isWasmInitialized) {
12220 throw new Error("initializeWasm() must be awaited first!");
12222 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_free(_res);
12223 // debug statements here
12225 // uintptr_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg);
12227 export function CResult_InvoiceSemanticErrorZ_clone_ptr(arg: number): number {
12228 if(!isWasmInitialized) {
12229 throw new Error("initializeWasm() must be awaited first!");
12231 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone_ptr(arg);
12232 return nativeResponseValue;
12234 // struct LDKCResult_InvoiceSemanticErrorZ CResult_InvoiceSemanticErrorZ_clone(const struct LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR orig);
12236 export function CResult_InvoiceSemanticErrorZ_clone(orig: number): number {
12237 if(!isWasmInitialized) {
12238 throw new Error("initializeWasm() must be awaited first!");
12240 const nativeResponseValue = wasm.TS_CResult_InvoiceSemanticErrorZ_clone(orig);
12241 return nativeResponseValue;
12243 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_ok(struct LDKDescription o);
12245 export function CResult_DescriptionCreationErrorZ_ok(o: number): number {
12246 if(!isWasmInitialized) {
12247 throw new Error("initializeWasm() must be awaited first!");
12249 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_ok(o);
12250 return nativeResponseValue;
12252 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_err(enum LDKCreationError e);
12254 export function CResult_DescriptionCreationErrorZ_err(e: CreationError): number {
12255 if(!isWasmInitialized) {
12256 throw new Error("initializeWasm() must be awaited first!");
12258 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_err(e);
12259 return nativeResponseValue;
12261 // bool CResult_DescriptionCreationErrorZ_is_ok(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR o);
12263 export function CResult_DescriptionCreationErrorZ_is_ok(o: number): boolean {
12264 if(!isWasmInitialized) {
12265 throw new Error("initializeWasm() must be awaited first!");
12267 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_is_ok(o);
12268 return nativeResponseValue;
12270 // void CResult_DescriptionCreationErrorZ_free(struct LDKCResult_DescriptionCreationErrorZ _res);
12272 export function CResult_DescriptionCreationErrorZ_free(_res: number): void {
12273 if(!isWasmInitialized) {
12274 throw new Error("initializeWasm() must be awaited first!");
12276 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_free(_res);
12277 // debug statements here
12279 // uintptr_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg);
12281 export function CResult_DescriptionCreationErrorZ_clone_ptr(arg: number): number {
12282 if(!isWasmInitialized) {
12283 throw new Error("initializeWasm() must be awaited first!");
12285 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone_ptr(arg);
12286 return nativeResponseValue;
12288 // struct LDKCResult_DescriptionCreationErrorZ CResult_DescriptionCreationErrorZ_clone(const struct LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR orig);
12290 export function CResult_DescriptionCreationErrorZ_clone(orig: number): number {
12291 if(!isWasmInitialized) {
12292 throw new Error("initializeWasm() must be awaited first!");
12294 const nativeResponseValue = wasm.TS_CResult_DescriptionCreationErrorZ_clone(orig);
12295 return nativeResponseValue;
12297 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_ok(struct LDKPrivateRoute o);
12299 export function CResult_PrivateRouteCreationErrorZ_ok(o: number): number {
12300 if(!isWasmInitialized) {
12301 throw new Error("initializeWasm() must be awaited first!");
12303 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_ok(o);
12304 return nativeResponseValue;
12306 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_err(enum LDKCreationError e);
12308 export function CResult_PrivateRouteCreationErrorZ_err(e: CreationError): number {
12309 if(!isWasmInitialized) {
12310 throw new Error("initializeWasm() must be awaited first!");
12312 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_err(e);
12313 return nativeResponseValue;
12315 // bool CResult_PrivateRouteCreationErrorZ_is_ok(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR o);
12317 export function CResult_PrivateRouteCreationErrorZ_is_ok(o: number): boolean {
12318 if(!isWasmInitialized) {
12319 throw new Error("initializeWasm() must be awaited first!");
12321 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_is_ok(o);
12322 return nativeResponseValue;
12324 // void CResult_PrivateRouteCreationErrorZ_free(struct LDKCResult_PrivateRouteCreationErrorZ _res);
12326 export function CResult_PrivateRouteCreationErrorZ_free(_res: number): void {
12327 if(!isWasmInitialized) {
12328 throw new Error("initializeWasm() must be awaited first!");
12330 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_free(_res);
12331 // debug statements here
12333 // uintptr_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg);
12335 export function CResult_PrivateRouteCreationErrorZ_clone_ptr(arg: number): number {
12336 if(!isWasmInitialized) {
12337 throw new Error("initializeWasm() must be awaited first!");
12339 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(arg);
12340 return nativeResponseValue;
12342 // struct LDKCResult_PrivateRouteCreationErrorZ CResult_PrivateRouteCreationErrorZ_clone(const struct LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR orig);
12344 export function CResult_PrivateRouteCreationErrorZ_clone(orig: number): number {
12345 if(!isWasmInitialized) {
12346 throw new Error("initializeWasm() must be awaited first!");
12348 const nativeResponseValue = wasm.TS_CResult_PrivateRouteCreationErrorZ_clone(orig);
12349 return nativeResponseValue;
12351 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_ok(struct LDKStr o);
12353 export function CResult_StringErrorZ_ok(o: number): number {
12354 if(!isWasmInitialized) {
12355 throw new Error("initializeWasm() must be awaited first!");
12357 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_ok(o);
12358 return nativeResponseValue;
12360 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_err(enum LDKSecp256k1Error e);
12362 export function CResult_StringErrorZ_err(e: Secp256k1Error): number {
12363 if(!isWasmInitialized) {
12364 throw new Error("initializeWasm() must be awaited first!");
12366 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_err(e);
12367 return nativeResponseValue;
12369 // bool CResult_StringErrorZ_is_ok(const struct LDKCResult_StringErrorZ *NONNULL_PTR o);
12371 export function CResult_StringErrorZ_is_ok(o: number): boolean {
12372 if(!isWasmInitialized) {
12373 throw new Error("initializeWasm() must be awaited first!");
12375 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_is_ok(o);
12376 return nativeResponseValue;
12378 // void CResult_StringErrorZ_free(struct LDKCResult_StringErrorZ _res);
12380 export function CResult_StringErrorZ_free(_res: number): void {
12381 if(!isWasmInitialized) {
12382 throw new Error("initializeWasm() must be awaited first!");
12384 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_free(_res);
12385 // debug statements here
12387 // uintptr_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg);
12389 export function CResult_StringErrorZ_clone_ptr(arg: number): number {
12390 if(!isWasmInitialized) {
12391 throw new Error("initializeWasm() must be awaited first!");
12393 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone_ptr(arg);
12394 return nativeResponseValue;
12396 // struct LDKCResult_StringErrorZ CResult_StringErrorZ_clone(const struct LDKCResult_StringErrorZ *NONNULL_PTR orig);
12398 export function CResult_StringErrorZ_clone(orig: number): number {
12399 if(!isWasmInitialized) {
12400 throw new Error("initializeWasm() must be awaited first!");
12402 const nativeResponseValue = wasm.TS_CResult_StringErrorZ_clone(orig);
12403 return nativeResponseValue;
12405 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
12407 export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
12408 if(!isWasmInitialized) {
12409 throw new Error("initializeWasm() must be awaited first!");
12411 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
12412 return nativeResponseValue;
12414 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12416 export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
12417 if(!isWasmInitialized) {
12418 throw new Error("initializeWasm() must be awaited first!");
12420 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
12421 return nativeResponseValue;
12423 // bool CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR o);
12425 export function CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o: number): boolean {
12426 if(!isWasmInitialized) {
12427 throw new Error("initializeWasm() must be awaited first!");
12429 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o);
12430 return nativeResponseValue;
12432 // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
12434 export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
12435 if(!isWasmInitialized) {
12436 throw new Error("initializeWasm() must be awaited first!");
12438 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
12439 // debug statements here
12441 // uintptr_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg);
12443 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg: number): number {
12444 if(!isWasmInitialized) {
12445 throw new Error("initializeWasm() must be awaited first!");
12447 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg);
12448 return nativeResponseValue;
12450 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
12452 export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
12453 if(!isWasmInitialized) {
12454 throw new Error("initializeWasm() must be awaited first!");
12456 const nativeResponseValue = wasm.TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
12457 return nativeResponseValue;
12459 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_some(struct LDKMonitorEvent o);
12461 export function COption_MonitorEventZ_some(o: number): number {
12462 if(!isWasmInitialized) {
12463 throw new Error("initializeWasm() must be awaited first!");
12465 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_some(o);
12466 return nativeResponseValue;
12468 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_none(void);
12470 export function COption_MonitorEventZ_none(): number {
12471 if(!isWasmInitialized) {
12472 throw new Error("initializeWasm() must be awaited first!");
12474 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_none();
12475 return nativeResponseValue;
12477 // void COption_MonitorEventZ_free(struct LDKCOption_MonitorEventZ _res);
12479 export function COption_MonitorEventZ_free(_res: number): void {
12480 if(!isWasmInitialized) {
12481 throw new Error("initializeWasm() must be awaited first!");
12483 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_free(_res);
12484 // debug statements here
12486 // uintptr_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg);
12488 export function COption_MonitorEventZ_clone_ptr(arg: number): number {
12489 if(!isWasmInitialized) {
12490 throw new Error("initializeWasm() must be awaited first!");
12492 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone_ptr(arg);
12493 return nativeResponseValue;
12495 // struct LDKCOption_MonitorEventZ COption_MonitorEventZ_clone(const struct LDKCOption_MonitorEventZ *NONNULL_PTR orig);
12497 export function COption_MonitorEventZ_clone(orig: number): number {
12498 if(!isWasmInitialized) {
12499 throw new Error("initializeWasm() must be awaited first!");
12501 const nativeResponseValue = wasm.TS_COption_MonitorEventZ_clone(orig);
12502 return nativeResponseValue;
12504 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_ok(struct LDKCOption_MonitorEventZ o);
12506 export function CResult_COption_MonitorEventZDecodeErrorZ_ok(o: number): number {
12507 if(!isWasmInitialized) {
12508 throw new Error("initializeWasm() must be awaited first!");
12510 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(o);
12511 return nativeResponseValue;
12513 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_err(struct LDKDecodeError e);
12515 export function CResult_COption_MonitorEventZDecodeErrorZ_err(e: number): number {
12516 if(!isWasmInitialized) {
12517 throw new Error("initializeWasm() must be awaited first!");
12519 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_err(e);
12520 return nativeResponseValue;
12522 // bool CResult_COption_MonitorEventZDecodeErrorZ_is_ok(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR o);
12524 export function CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o: number): boolean {
12525 if(!isWasmInitialized) {
12526 throw new Error("initializeWasm() must be awaited first!");
12528 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o);
12529 return nativeResponseValue;
12531 // void CResult_COption_MonitorEventZDecodeErrorZ_free(struct LDKCResult_COption_MonitorEventZDecodeErrorZ _res);
12533 export function CResult_COption_MonitorEventZDecodeErrorZ_free(_res: number): void {
12534 if(!isWasmInitialized) {
12535 throw new Error("initializeWasm() must be awaited first!");
12537 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_free(_res);
12538 // debug statements here
12540 // uintptr_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg);
12542 export function CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg: number): number {
12543 if(!isWasmInitialized) {
12544 throw new Error("initializeWasm() must be awaited first!");
12546 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg);
12547 return nativeResponseValue;
12549 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ CResult_COption_MonitorEventZDecodeErrorZ_clone(const struct LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR orig);
12551 export function CResult_COption_MonitorEventZDecodeErrorZ_clone(orig: number): number {
12552 if(!isWasmInitialized) {
12553 throw new Error("initializeWasm() must be awaited first!");
12555 const nativeResponseValue = wasm.TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(orig);
12556 return nativeResponseValue;
12558 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
12560 export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
12561 if(!isWasmInitialized) {
12562 throw new Error("initializeWasm() must be awaited first!");
12564 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_ok(o);
12565 return nativeResponseValue;
12567 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
12569 export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
12570 if(!isWasmInitialized) {
12571 throw new Error("initializeWasm() must be awaited first!");
12573 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_err(e);
12574 return nativeResponseValue;
12576 // bool CResult_HTLCUpdateDecodeErrorZ_is_ok(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR o);
12578 export function CResult_HTLCUpdateDecodeErrorZ_is_ok(o: number): boolean {
12579 if(!isWasmInitialized) {
12580 throw new Error("initializeWasm() must be awaited first!");
12582 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(o);
12583 return nativeResponseValue;
12585 // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
12587 export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
12588 if(!isWasmInitialized) {
12589 throw new Error("initializeWasm() must be awaited first!");
12591 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_free(_res);
12592 // debug statements here
12594 // uintptr_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg);
12596 export function CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg: number): number {
12597 if(!isWasmInitialized) {
12598 throw new Error("initializeWasm() must be awaited first!");
12600 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg);
12601 return nativeResponseValue;
12603 // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
12605 export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
12606 if(!isWasmInitialized) {
12607 throw new Error("initializeWasm() must be awaited first!");
12609 const nativeResponseValue = wasm.TS_CResult_HTLCUpdateDecodeErrorZ_clone(orig);
12610 return nativeResponseValue;
12612 // uintptr_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg);
12614 export function C2Tuple_OutPointScriptZ_clone_ptr(arg: number): number {
12615 if(!isWasmInitialized) {
12616 throw new Error("initializeWasm() must be awaited first!");
12618 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone_ptr(arg);
12619 return nativeResponseValue;
12621 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
12623 export function C2Tuple_OutPointScriptZ_clone(orig: number): number {
12624 if(!isWasmInitialized) {
12625 throw new Error("initializeWasm() must be awaited first!");
12627 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_clone(orig);
12628 return nativeResponseValue;
12630 // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
12632 export function C2Tuple_OutPointScriptZ_new(a: number, b: number): number {
12633 if(!isWasmInitialized) {
12634 throw new Error("initializeWasm() must be awaited first!");
12636 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_new(a, b);
12637 return nativeResponseValue;
12639 // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
12641 export function C2Tuple_OutPointScriptZ_free(_res: number): void {
12642 if(!isWasmInitialized) {
12643 throw new Error("initializeWasm() must be awaited first!");
12645 const nativeResponseValue = wasm.TS_C2Tuple_OutPointScriptZ_free(_res);
12646 // debug statements here
12648 // uintptr_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg);
12650 export function C2Tuple_u32ScriptZ_clone_ptr(arg: number): number {
12651 if(!isWasmInitialized) {
12652 throw new Error("initializeWasm() must be awaited first!");
12654 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone_ptr(arg);
12655 return nativeResponseValue;
12657 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig);
12659 export function C2Tuple_u32ScriptZ_clone(orig: number): number {
12660 if(!isWasmInitialized) {
12661 throw new Error("initializeWasm() must be awaited first!");
12663 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_clone(orig);
12664 return nativeResponseValue;
12666 // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
12668 export function C2Tuple_u32ScriptZ_new(a: number, b: number): number {
12669 if(!isWasmInitialized) {
12670 throw new Error("initializeWasm() must be awaited first!");
12672 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_new(a, b);
12673 return nativeResponseValue;
12675 // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
12677 export function C2Tuple_u32ScriptZ_free(_res: number): void {
12678 if(!isWasmInitialized) {
12679 throw new Error("initializeWasm() must be awaited first!");
12681 const nativeResponseValue = wasm.TS_C2Tuple_u32ScriptZ_free(_res);
12682 // debug statements here
12684 // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
12686 export function CVec_C2Tuple_u32ScriptZZ_free(_res: number): void {
12687 if(!isWasmInitialized) {
12688 throw new Error("initializeWasm() must be awaited first!");
12690 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32ScriptZZ_free(_res);
12691 // debug statements here
12693 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg);
12695 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg: number): number {
12696 if(!isWasmInitialized) {
12697 throw new Error("initializeWasm() must be awaited first!");
12699 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg);
12700 return nativeResponseValue;
12702 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR orig);
12704 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig: number): number {
12705 if(!isWasmInitialized) {
12706 throw new Error("initializeWasm() must be awaited first!");
12708 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig);
12709 return nativeResponseValue;
12711 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
12713 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: number, b: number): number {
12714 if(!isWasmInitialized) {
12715 throw new Error("initializeWasm() must be awaited first!");
12717 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a, b);
12718 return nativeResponseValue;
12720 // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
12722 export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: number): void {
12723 if(!isWasmInitialized) {
12724 throw new Error("initializeWasm() must be awaited first!");
12726 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
12727 // debug statements here
12729 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
12731 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number): void {
12732 if(!isWasmInitialized) {
12733 throw new Error("initializeWasm() must be awaited first!");
12735 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
12736 // debug statements here
12738 // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
12740 export function CVec_EventZ_free(_res: number): void {
12741 if(!isWasmInitialized) {
12742 throw new Error("initializeWasm() must be awaited first!");
12744 const nativeResponseValue = wasm.TS_CVec_EventZ_free(_res);
12745 // debug statements here
12747 // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
12749 export function CVec_TransactionZ_free(_res: number): void {
12750 if(!isWasmInitialized) {
12751 throw new Error("initializeWasm() must be awaited first!");
12753 const nativeResponseValue = wasm.TS_CVec_TransactionZ_free(_res);
12754 // debug statements here
12756 // uintptr_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg);
12758 export function C2Tuple_u32TxOutZ_clone_ptr(arg: number): number {
12759 if(!isWasmInitialized) {
12760 throw new Error("initializeWasm() must be awaited first!");
12762 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone_ptr(arg);
12763 return nativeResponseValue;
12765 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
12767 export function C2Tuple_u32TxOutZ_clone(orig: number): number {
12768 if(!isWasmInitialized) {
12769 throw new Error("initializeWasm() must be awaited first!");
12771 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_clone(orig);
12772 return nativeResponseValue;
12774 // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
12776 export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
12777 if(!isWasmInitialized) {
12778 throw new Error("initializeWasm() must be awaited first!");
12780 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_new(a, b);
12781 return nativeResponseValue;
12783 // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
12785 export function C2Tuple_u32TxOutZ_free(_res: number): void {
12786 if(!isWasmInitialized) {
12787 throw new Error("initializeWasm() must be awaited first!");
12789 const nativeResponseValue = wasm.TS_C2Tuple_u32TxOutZ_free(_res);
12790 // debug statements here
12792 // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
12794 export function CVec_C2Tuple_u32TxOutZZ_free(_res: number): void {
12795 if(!isWasmInitialized) {
12796 throw new Error("initializeWasm() must be awaited first!");
12798 const nativeResponseValue = wasm.TS_CVec_C2Tuple_u32TxOutZZ_free(_res);
12799 // debug statements here
12801 // uintptr_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg);
12803 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg: number): number {
12804 if(!isWasmInitialized) {
12805 throw new Error("initializeWasm() must be awaited first!");
12807 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg);
12808 return nativeResponseValue;
12810 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(const struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR orig);
12812 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig: number): number {
12813 if(!isWasmInitialized) {
12814 throw new Error("initializeWasm() must be awaited first!");
12816 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig);
12817 return nativeResponseValue;
12819 // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
12821 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: number, b: number): number {
12822 if(!isWasmInitialized) {
12823 throw new Error("initializeWasm() must be awaited first!");
12825 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a, b);
12826 return nativeResponseValue;
12828 // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
12830 export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
12831 if(!isWasmInitialized) {
12832 throw new Error("initializeWasm() must be awaited first!");
12834 const nativeResponseValue = wasm.TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
12835 // debug statements here
12837 // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
12839 export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number): void {
12840 if(!isWasmInitialized) {
12841 throw new Error("initializeWasm() must be awaited first!");
12843 const nativeResponseValue = wasm.TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
12844 // debug statements here
12846 // void CVec_BalanceZ_free(struct LDKCVec_BalanceZ _res);
12848 export function CVec_BalanceZ_free(_res: number): void {
12849 if(!isWasmInitialized) {
12850 throw new Error("initializeWasm() must be awaited first!");
12852 const nativeResponseValue = wasm.TS_CVec_BalanceZ_free(_res);
12853 // debug statements here
12855 // uintptr_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg);
12857 export function C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg: number): number {
12858 if(!isWasmInitialized) {
12859 throw new Error("initializeWasm() must be awaited first!");
12861 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg);
12862 return nativeResponseValue;
12864 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_clone(const struct LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR orig);
12866 export function C2Tuple_BlockHashChannelMonitorZ_clone(orig: number): number {
12867 if(!isWasmInitialized) {
12868 throw new Error("initializeWasm() must be awaited first!");
12870 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_clone(orig);
12871 return nativeResponseValue;
12873 // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
12875 export function C2Tuple_BlockHashChannelMonitorZ_new(a: number, b: number): number {
12876 if(!isWasmInitialized) {
12877 throw new Error("initializeWasm() must be awaited first!");
12879 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_new(a, b);
12880 return nativeResponseValue;
12882 // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
12884 export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
12885 if(!isWasmInitialized) {
12886 throw new Error("initializeWasm() must be awaited first!");
12888 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_free(_res);
12889 // debug statements here
12891 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
12893 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
12894 if(!isWasmInitialized) {
12895 throw new Error("initializeWasm() must be awaited first!");
12897 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
12898 return nativeResponseValue;
12900 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
12902 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
12903 if(!isWasmInitialized) {
12904 throw new Error("initializeWasm() must be awaited first!");
12906 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
12907 return nativeResponseValue;
12909 // bool CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR o);
12911 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o: number): boolean {
12912 if(!isWasmInitialized) {
12913 throw new Error("initializeWasm() must be awaited first!");
12915 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o);
12916 return nativeResponseValue;
12918 // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
12920 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
12921 if(!isWasmInitialized) {
12922 throw new Error("initializeWasm() must be awaited first!");
12924 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
12925 // debug statements here
12927 // uintptr_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg);
12929 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg: number): number {
12930 if(!isWasmInitialized) {
12931 throw new Error("initializeWasm() must be awaited first!");
12933 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg);
12934 return nativeResponseValue;
12936 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(const struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR orig);
12938 export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig: number): number {
12939 if(!isWasmInitialized) {
12940 throw new Error("initializeWasm() must be awaited first!");
12942 const nativeResponseValue = wasm.TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig);
12943 return nativeResponseValue;
12945 // uintptr_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg);
12947 export function C2Tuple_PublicKeyTypeZ_clone_ptr(arg: number): number {
12948 if(!isWasmInitialized) {
12949 throw new Error("initializeWasm() must be awaited first!");
12951 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone_ptr(arg);
12952 return nativeResponseValue;
12954 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_clone(const struct LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR orig);
12956 export function C2Tuple_PublicKeyTypeZ_clone(orig: number): number {
12957 if(!isWasmInitialized) {
12958 throw new Error("initializeWasm() must be awaited first!");
12960 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_clone(orig);
12961 return nativeResponseValue;
12963 // struct LDKC2Tuple_PublicKeyTypeZ C2Tuple_PublicKeyTypeZ_new(struct LDKPublicKey a, struct LDKType b);
12965 export function C2Tuple_PublicKeyTypeZ_new(a: number, b: number): number {
12966 if(!isWasmInitialized) {
12967 throw new Error("initializeWasm() must be awaited first!");
12969 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_new(a, b);
12970 return nativeResponseValue;
12972 // void C2Tuple_PublicKeyTypeZ_free(struct LDKC2Tuple_PublicKeyTypeZ _res);
12974 export function C2Tuple_PublicKeyTypeZ_free(_res: number): void {
12975 if(!isWasmInitialized) {
12976 throw new Error("initializeWasm() must be awaited first!");
12978 const nativeResponseValue = wasm.TS_C2Tuple_PublicKeyTypeZ_free(_res);
12979 // debug statements here
12981 // void CVec_C2Tuple_PublicKeyTypeZZ_free(struct LDKCVec_C2Tuple_PublicKeyTypeZZ _res);
12983 export function CVec_C2Tuple_PublicKeyTypeZZ_free(_res: number): void {
12984 if(!isWasmInitialized) {
12985 throw new Error("initializeWasm() must be awaited first!");
12987 const nativeResponseValue = wasm.TS_CVec_C2Tuple_PublicKeyTypeZZ_free(_res);
12988 // debug statements here
12990 // struct LDKCOption_NetAddressZ COption_NetAddressZ_some(struct LDKNetAddress o);
12992 export function COption_NetAddressZ_some(o: number): number {
12993 if(!isWasmInitialized) {
12994 throw new Error("initializeWasm() must be awaited first!");
12996 const nativeResponseValue = wasm.TS_COption_NetAddressZ_some(o);
12997 return nativeResponseValue;
12999 // struct LDKCOption_NetAddressZ COption_NetAddressZ_none(void);
13001 export function COption_NetAddressZ_none(): number {
13002 if(!isWasmInitialized) {
13003 throw new Error("initializeWasm() must be awaited first!");
13005 const nativeResponseValue = wasm.TS_COption_NetAddressZ_none();
13006 return nativeResponseValue;
13008 // void COption_NetAddressZ_free(struct LDKCOption_NetAddressZ _res);
13010 export function COption_NetAddressZ_free(_res: number): void {
13011 if(!isWasmInitialized) {
13012 throw new Error("initializeWasm() must be awaited first!");
13014 const nativeResponseValue = wasm.TS_COption_NetAddressZ_free(_res);
13015 // debug statements here
13017 // uintptr_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg);
13019 export function COption_NetAddressZ_clone_ptr(arg: number): number {
13020 if(!isWasmInitialized) {
13021 throw new Error("initializeWasm() must be awaited first!");
13023 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone_ptr(arg);
13024 return nativeResponseValue;
13026 // struct LDKCOption_NetAddressZ COption_NetAddressZ_clone(const struct LDKCOption_NetAddressZ *NONNULL_PTR orig);
13028 export function COption_NetAddressZ_clone(orig: number): number {
13029 if(!isWasmInitialized) {
13030 throw new Error("initializeWasm() must be awaited first!");
13032 const nativeResponseValue = wasm.TS_COption_NetAddressZ_clone(orig);
13033 return nativeResponseValue;
13035 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
13037 export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: number): number {
13038 if(!isWasmInitialized) {
13039 throw new Error("initializeWasm() must be awaited first!");
13041 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(o);
13042 return nativeResponseValue;
13044 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
13046 export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
13047 if(!isWasmInitialized) {
13048 throw new Error("initializeWasm() must be awaited first!");
13050 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_err(e);
13051 return nativeResponseValue;
13053 // bool CResult_CVec_u8ZPeerHandleErrorZ_is_ok(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR o);
13055 export function CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o: number): boolean {
13056 if(!isWasmInitialized) {
13057 throw new Error("initializeWasm() must be awaited first!");
13059 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o);
13060 return nativeResponseValue;
13062 // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
13064 export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
13065 if(!isWasmInitialized) {
13066 throw new Error("initializeWasm() must be awaited first!");
13068 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
13069 // debug statements here
13071 // uintptr_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg);
13073 export function CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg: number): number {
13074 if(!isWasmInitialized) {
13075 throw new Error("initializeWasm() must be awaited first!");
13077 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg);
13078 return nativeResponseValue;
13080 // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
13082 export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
13083 if(!isWasmInitialized) {
13084 throw new Error("initializeWasm() must be awaited first!");
13086 const nativeResponseValue = wasm.TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
13087 return nativeResponseValue;
13089 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
13091 export function CResult_NonePeerHandleErrorZ_ok(): number {
13092 if(!isWasmInitialized) {
13093 throw new Error("initializeWasm() must be awaited first!");
13095 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_ok();
13096 return nativeResponseValue;
13098 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
13100 export function CResult_NonePeerHandleErrorZ_err(e: number): number {
13101 if(!isWasmInitialized) {
13102 throw new Error("initializeWasm() must be awaited first!");
13104 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_err(e);
13105 return nativeResponseValue;
13107 // bool CResult_NonePeerHandleErrorZ_is_ok(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR o);
13109 export function CResult_NonePeerHandleErrorZ_is_ok(o: number): boolean {
13110 if(!isWasmInitialized) {
13111 throw new Error("initializeWasm() must be awaited first!");
13113 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_is_ok(o);
13114 return nativeResponseValue;
13116 // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
13118 export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
13119 if(!isWasmInitialized) {
13120 throw new Error("initializeWasm() must be awaited first!");
13122 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_free(_res);
13123 // debug statements here
13125 // uintptr_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg);
13127 export function CResult_NonePeerHandleErrorZ_clone_ptr(arg: number): number {
13128 if(!isWasmInitialized) {
13129 throw new Error("initializeWasm() must be awaited first!");
13131 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone_ptr(arg);
13132 return nativeResponseValue;
13134 // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
13136 export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
13137 if(!isWasmInitialized) {
13138 throw new Error("initializeWasm() must be awaited first!");
13140 const nativeResponseValue = wasm.TS_CResult_NonePeerHandleErrorZ_clone(orig);
13141 return nativeResponseValue;
13143 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
13145 export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
13146 if(!isWasmInitialized) {
13147 throw new Error("initializeWasm() must be awaited first!");
13149 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_ok(o);
13150 return nativeResponseValue;
13152 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
13154 export function CResult_boolPeerHandleErrorZ_err(e: number): number {
13155 if(!isWasmInitialized) {
13156 throw new Error("initializeWasm() must be awaited first!");
13158 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_err(e);
13159 return nativeResponseValue;
13161 // bool CResult_boolPeerHandleErrorZ_is_ok(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR o);
13163 export function CResult_boolPeerHandleErrorZ_is_ok(o: number): boolean {
13164 if(!isWasmInitialized) {
13165 throw new Error("initializeWasm() must be awaited first!");
13167 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_is_ok(o);
13168 return nativeResponseValue;
13170 // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
13172 export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
13173 if(!isWasmInitialized) {
13174 throw new Error("initializeWasm() must be awaited first!");
13176 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_free(_res);
13177 // debug statements here
13179 // uintptr_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg);
13181 export function CResult_boolPeerHandleErrorZ_clone_ptr(arg: number): number {
13182 if(!isWasmInitialized) {
13183 throw new Error("initializeWasm() must be awaited first!");
13185 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone_ptr(arg);
13186 return nativeResponseValue;
13188 // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
13190 export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
13191 if(!isWasmInitialized) {
13192 throw new Error("initializeWasm() must be awaited first!");
13194 const nativeResponseValue = wasm.TS_CResult_boolPeerHandleErrorZ_clone(orig);
13195 return nativeResponseValue;
13197 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
13199 export function CResult_NoneErrorZ_ok(): number {
13200 if(!isWasmInitialized) {
13201 throw new Error("initializeWasm() must be awaited first!");
13203 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_ok();
13204 return nativeResponseValue;
13206 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
13208 export function CResult_NoneErrorZ_err(e: IOError): number {
13209 if(!isWasmInitialized) {
13210 throw new Error("initializeWasm() must be awaited first!");
13212 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_err(e);
13213 return nativeResponseValue;
13215 // bool CResult_NoneErrorZ_is_ok(const struct LDKCResult_NoneErrorZ *NONNULL_PTR o);
13217 export function CResult_NoneErrorZ_is_ok(o: number): boolean {
13218 if(!isWasmInitialized) {
13219 throw new Error("initializeWasm() must be awaited first!");
13221 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_is_ok(o);
13222 return nativeResponseValue;
13224 // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
13226 export function CResult_NoneErrorZ_free(_res: number): void {
13227 if(!isWasmInitialized) {
13228 throw new Error("initializeWasm() must be awaited first!");
13230 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_free(_res);
13231 // debug statements here
13233 // uintptr_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg);
13235 export function CResult_NoneErrorZ_clone_ptr(arg: number): number {
13236 if(!isWasmInitialized) {
13237 throw new Error("initializeWasm() must be awaited first!");
13239 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone_ptr(arg);
13240 return nativeResponseValue;
13242 // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_clone(const struct LDKCResult_NoneErrorZ *NONNULL_PTR orig);
13244 export function CResult_NoneErrorZ_clone(orig: number): number {
13245 if(!isWasmInitialized) {
13246 throw new Error("initializeWasm() must be awaited first!");
13248 const nativeResponseValue = wasm.TS_CResult_NoneErrorZ_clone(orig);
13249 return nativeResponseValue;
13251 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_ok(struct LDKNetAddress o);
13253 export function CResult_NetAddressDecodeErrorZ_ok(o: number): number {
13254 if(!isWasmInitialized) {
13255 throw new Error("initializeWasm() must be awaited first!");
13257 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_ok(o);
13258 return nativeResponseValue;
13260 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_err(struct LDKDecodeError e);
13262 export function CResult_NetAddressDecodeErrorZ_err(e: number): number {
13263 if(!isWasmInitialized) {
13264 throw new Error("initializeWasm() must be awaited first!");
13266 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_err(e);
13267 return nativeResponseValue;
13269 // bool CResult_NetAddressDecodeErrorZ_is_ok(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR o);
13271 export function CResult_NetAddressDecodeErrorZ_is_ok(o: number): boolean {
13272 if(!isWasmInitialized) {
13273 throw new Error("initializeWasm() must be awaited first!");
13275 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_is_ok(o);
13276 return nativeResponseValue;
13278 // void CResult_NetAddressDecodeErrorZ_free(struct LDKCResult_NetAddressDecodeErrorZ _res);
13280 export function CResult_NetAddressDecodeErrorZ_free(_res: number): void {
13281 if(!isWasmInitialized) {
13282 throw new Error("initializeWasm() must be awaited first!");
13284 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_free(_res);
13285 // debug statements here
13287 // uintptr_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg);
13289 export function CResult_NetAddressDecodeErrorZ_clone_ptr(arg: number): number {
13290 if(!isWasmInitialized) {
13291 throw new Error("initializeWasm() must be awaited first!");
13293 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone_ptr(arg);
13294 return nativeResponseValue;
13296 // struct LDKCResult_NetAddressDecodeErrorZ CResult_NetAddressDecodeErrorZ_clone(const struct LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR orig);
13298 export function CResult_NetAddressDecodeErrorZ_clone(orig: number): number {
13299 if(!isWasmInitialized) {
13300 throw new Error("initializeWasm() must be awaited first!");
13302 const nativeResponseValue = wasm.TS_CResult_NetAddressDecodeErrorZ_clone(orig);
13303 return nativeResponseValue;
13305 // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
13307 export function CVec_UpdateAddHTLCZ_free(_res: number): void {
13308 if(!isWasmInitialized) {
13309 throw new Error("initializeWasm() must be awaited first!");
13311 const nativeResponseValue = wasm.TS_CVec_UpdateAddHTLCZ_free(_res);
13312 // debug statements here
13314 // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
13316 export function CVec_UpdateFulfillHTLCZ_free(_res: number): void {
13317 if(!isWasmInitialized) {
13318 throw new Error("initializeWasm() must be awaited first!");
13320 const nativeResponseValue = wasm.TS_CVec_UpdateFulfillHTLCZ_free(_res);
13321 // debug statements here
13323 // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
13325 export function CVec_UpdateFailHTLCZ_free(_res: number): void {
13326 if(!isWasmInitialized) {
13327 throw new Error("initializeWasm() must be awaited first!");
13329 const nativeResponseValue = wasm.TS_CVec_UpdateFailHTLCZ_free(_res);
13330 // debug statements here
13332 // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
13334 export function CVec_UpdateFailMalformedHTLCZ_free(_res: number): void {
13335 if(!isWasmInitialized) {
13336 throw new Error("initializeWasm() must be awaited first!");
13338 const nativeResponseValue = wasm.TS_CVec_UpdateFailMalformedHTLCZ_free(_res);
13339 // debug statements here
13341 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
13343 export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
13344 if(!isWasmInitialized) {
13345 throw new Error("initializeWasm() must be awaited first!");
13347 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_ok(o);
13348 return nativeResponseValue;
13350 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
13352 export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
13353 if(!isWasmInitialized) {
13354 throw new Error("initializeWasm() must be awaited first!");
13356 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_err(e);
13357 return nativeResponseValue;
13359 // bool CResult_AcceptChannelDecodeErrorZ_is_ok(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR o);
13361 export function CResult_AcceptChannelDecodeErrorZ_is_ok(o: number): boolean {
13362 if(!isWasmInitialized) {
13363 throw new Error("initializeWasm() must be awaited first!");
13365 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_is_ok(o);
13366 return nativeResponseValue;
13368 // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
13370 export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
13371 if(!isWasmInitialized) {
13372 throw new Error("initializeWasm() must be awaited first!");
13374 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_free(_res);
13375 // debug statements here
13377 // uintptr_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg);
13379 export function CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg: number): number {
13380 if(!isWasmInitialized) {
13381 throw new Error("initializeWasm() must be awaited first!");
13383 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg);
13384 return nativeResponseValue;
13386 // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
13388 export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
13389 if(!isWasmInitialized) {
13390 throw new Error("initializeWasm() must be awaited first!");
13392 const nativeResponseValue = wasm.TS_CResult_AcceptChannelDecodeErrorZ_clone(orig);
13393 return nativeResponseValue;
13395 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
13397 export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
13398 if(!isWasmInitialized) {
13399 throw new Error("initializeWasm() must be awaited first!");
13401 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
13402 return nativeResponseValue;
13404 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
13406 export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
13407 if(!isWasmInitialized) {
13408 throw new Error("initializeWasm() must be awaited first!");
13410 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
13411 return nativeResponseValue;
13413 // bool CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR o);
13415 export function CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o: number): boolean {
13416 if(!isWasmInitialized) {
13417 throw new Error("initializeWasm() must be awaited first!");
13419 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o);
13420 return nativeResponseValue;
13422 // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
13424 export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
13425 if(!isWasmInitialized) {
13426 throw new Error("initializeWasm() must be awaited first!");
13428 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
13429 // debug statements here
13431 // uintptr_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg);
13433 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg: number): number {
13434 if(!isWasmInitialized) {
13435 throw new Error("initializeWasm() must be awaited first!");
13437 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg);
13438 return nativeResponseValue;
13440 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
13442 export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
13443 if(!isWasmInitialized) {
13444 throw new Error("initializeWasm() must be awaited first!");
13446 const nativeResponseValue = wasm.TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
13447 return nativeResponseValue;
13449 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
13451 export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
13452 if(!isWasmInitialized) {
13453 throw new Error("initializeWasm() must be awaited first!");
13455 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_ok(o);
13456 return nativeResponseValue;
13458 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
13460 export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
13461 if(!isWasmInitialized) {
13462 throw new Error("initializeWasm() must be awaited first!");
13464 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_err(e);
13465 return nativeResponseValue;
13467 // bool CResult_ChannelReestablishDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR o);
13469 export function CResult_ChannelReestablishDecodeErrorZ_is_ok(o: number): boolean {
13470 if(!isWasmInitialized) {
13471 throw new Error("initializeWasm() must be awaited first!");
13473 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(o);
13474 return nativeResponseValue;
13476 // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
13478 export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
13479 if(!isWasmInitialized) {
13480 throw new Error("initializeWasm() must be awaited first!");
13482 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_free(_res);
13483 // debug statements here
13485 // uintptr_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg);
13487 export function CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg: number): number {
13488 if(!isWasmInitialized) {
13489 throw new Error("initializeWasm() must be awaited first!");
13491 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg);
13492 return nativeResponseValue;
13494 // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
13496 export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
13497 if(!isWasmInitialized) {
13498 throw new Error("initializeWasm() must be awaited first!");
13500 const nativeResponseValue = wasm.TS_CResult_ChannelReestablishDecodeErrorZ_clone(orig);
13501 return nativeResponseValue;
13503 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
13505 export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
13506 if(!isWasmInitialized) {
13507 throw new Error("initializeWasm() must be awaited first!");
13509 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_ok(o);
13510 return nativeResponseValue;
13512 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13514 export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
13515 if(!isWasmInitialized) {
13516 throw new Error("initializeWasm() must be awaited first!");
13518 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_err(e);
13519 return nativeResponseValue;
13521 // bool CResult_ClosingSignedDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR o);
13523 export function CResult_ClosingSignedDecodeErrorZ_is_ok(o: number): boolean {
13524 if(!isWasmInitialized) {
13525 throw new Error("initializeWasm() must be awaited first!");
13527 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_is_ok(o);
13528 return nativeResponseValue;
13530 // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
13532 export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
13533 if(!isWasmInitialized) {
13534 throw new Error("initializeWasm() must be awaited first!");
13536 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_free(_res);
13537 // debug statements here
13539 // uintptr_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg);
13541 export function CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg: number): number {
13542 if(!isWasmInitialized) {
13543 throw new Error("initializeWasm() must be awaited first!");
13545 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg);
13546 return nativeResponseValue;
13548 // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
13550 export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
13551 if(!isWasmInitialized) {
13552 throw new Error("initializeWasm() must be awaited first!");
13554 const nativeResponseValue = wasm.TS_CResult_ClosingSignedDecodeErrorZ_clone(orig);
13555 return nativeResponseValue;
13557 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(struct LDKClosingSignedFeeRange o);
13559 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o: number): number {
13560 if(!isWasmInitialized) {
13561 throw new Error("initializeWasm() must be awaited first!");
13563 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o);
13564 return nativeResponseValue;
13566 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_err(struct LDKDecodeError e);
13568 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e: number): number {
13569 if(!isWasmInitialized) {
13570 throw new Error("initializeWasm() must be awaited first!");
13572 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e);
13573 return nativeResponseValue;
13575 // bool CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR o);
13577 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o: number): boolean {
13578 if(!isWasmInitialized) {
13579 throw new Error("initializeWasm() must be awaited first!");
13581 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o);
13582 return nativeResponseValue;
13584 // void CResult_ClosingSignedFeeRangeDecodeErrorZ_free(struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res);
13586 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res: number): void {
13587 if(!isWasmInitialized) {
13588 throw new Error("initializeWasm() must be awaited first!");
13590 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res);
13591 // debug statements here
13593 // uintptr_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg);
13595 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg: number): number {
13596 if(!isWasmInitialized) {
13597 throw new Error("initializeWasm() must be awaited first!");
13599 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg);
13600 return nativeResponseValue;
13602 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR orig);
13604 export function CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig: number): number {
13605 if(!isWasmInitialized) {
13606 throw new Error("initializeWasm() must be awaited first!");
13608 const nativeResponseValue = wasm.TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig);
13609 return nativeResponseValue;
13611 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
13613 export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
13614 if(!isWasmInitialized) {
13615 throw new Error("initializeWasm() must be awaited first!");
13617 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_ok(o);
13618 return nativeResponseValue;
13620 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
13622 export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
13623 if(!isWasmInitialized) {
13624 throw new Error("initializeWasm() must be awaited first!");
13626 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_err(e);
13627 return nativeResponseValue;
13629 // bool CResult_CommitmentSignedDecodeErrorZ_is_ok(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR o);
13631 export function CResult_CommitmentSignedDecodeErrorZ_is_ok(o: number): boolean {
13632 if(!isWasmInitialized) {
13633 throw new Error("initializeWasm() must be awaited first!");
13635 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(o);
13636 return nativeResponseValue;
13638 // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
13640 export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
13641 if(!isWasmInitialized) {
13642 throw new Error("initializeWasm() must be awaited first!");
13644 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_free(_res);
13645 // debug statements here
13647 // uintptr_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg);
13649 export function CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg: number): number {
13650 if(!isWasmInitialized) {
13651 throw new Error("initializeWasm() must be awaited first!");
13653 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg);
13654 return nativeResponseValue;
13656 // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
13658 export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
13659 if(!isWasmInitialized) {
13660 throw new Error("initializeWasm() must be awaited first!");
13662 const nativeResponseValue = wasm.TS_CResult_CommitmentSignedDecodeErrorZ_clone(orig);
13663 return nativeResponseValue;
13665 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
13667 export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
13668 if(!isWasmInitialized) {
13669 throw new Error("initializeWasm() must be awaited first!");
13671 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_ok(o);
13672 return nativeResponseValue;
13674 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
13676 export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
13677 if(!isWasmInitialized) {
13678 throw new Error("initializeWasm() must be awaited first!");
13680 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_err(e);
13681 return nativeResponseValue;
13683 // bool CResult_FundingCreatedDecodeErrorZ_is_ok(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR o);
13685 export function CResult_FundingCreatedDecodeErrorZ_is_ok(o: number): boolean {
13686 if(!isWasmInitialized) {
13687 throw new Error("initializeWasm() must be awaited first!");
13689 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_is_ok(o);
13690 return nativeResponseValue;
13692 // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
13694 export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
13695 if(!isWasmInitialized) {
13696 throw new Error("initializeWasm() must be awaited first!");
13698 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_free(_res);
13699 // debug statements here
13701 // uintptr_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg);
13703 export function CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg: number): number {
13704 if(!isWasmInitialized) {
13705 throw new Error("initializeWasm() must be awaited first!");
13707 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg);
13708 return nativeResponseValue;
13710 // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
13712 export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
13713 if(!isWasmInitialized) {
13714 throw new Error("initializeWasm() must be awaited first!");
13716 const nativeResponseValue = wasm.TS_CResult_FundingCreatedDecodeErrorZ_clone(orig);
13717 return nativeResponseValue;
13719 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
13721 export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
13722 if(!isWasmInitialized) {
13723 throw new Error("initializeWasm() must be awaited first!");
13725 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_ok(o);
13726 return nativeResponseValue;
13728 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
13730 export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
13731 if(!isWasmInitialized) {
13732 throw new Error("initializeWasm() must be awaited first!");
13734 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_err(e);
13735 return nativeResponseValue;
13737 // bool CResult_FundingSignedDecodeErrorZ_is_ok(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR o);
13739 export function CResult_FundingSignedDecodeErrorZ_is_ok(o: number): boolean {
13740 if(!isWasmInitialized) {
13741 throw new Error("initializeWasm() must be awaited first!");
13743 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_is_ok(o);
13744 return nativeResponseValue;
13746 // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
13748 export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
13749 if(!isWasmInitialized) {
13750 throw new Error("initializeWasm() must be awaited first!");
13752 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_free(_res);
13753 // debug statements here
13755 // uintptr_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg);
13757 export function CResult_FundingSignedDecodeErrorZ_clone_ptr(arg: number): number {
13758 if(!isWasmInitialized) {
13759 throw new Error("initializeWasm() must be awaited first!");
13761 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(arg);
13762 return nativeResponseValue;
13764 // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
13766 export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
13767 if(!isWasmInitialized) {
13768 throw new Error("initializeWasm() must be awaited first!");
13770 const nativeResponseValue = wasm.TS_CResult_FundingSignedDecodeErrorZ_clone(orig);
13771 return nativeResponseValue;
13773 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_ok(struct LDKChannelReady o);
13775 export function CResult_ChannelReadyDecodeErrorZ_ok(o: number): number {
13776 if(!isWasmInitialized) {
13777 throw new Error("initializeWasm() must be awaited first!");
13779 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_ok(o);
13780 return nativeResponseValue;
13782 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_err(struct LDKDecodeError e);
13784 export function CResult_ChannelReadyDecodeErrorZ_err(e: number): number {
13785 if(!isWasmInitialized) {
13786 throw new Error("initializeWasm() must be awaited first!");
13788 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_err(e);
13789 return nativeResponseValue;
13791 // bool CResult_ChannelReadyDecodeErrorZ_is_ok(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR o);
13793 export function CResult_ChannelReadyDecodeErrorZ_is_ok(o: number): boolean {
13794 if(!isWasmInitialized) {
13795 throw new Error("initializeWasm() must be awaited first!");
13797 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_is_ok(o);
13798 return nativeResponseValue;
13800 // void CResult_ChannelReadyDecodeErrorZ_free(struct LDKCResult_ChannelReadyDecodeErrorZ _res);
13802 export function CResult_ChannelReadyDecodeErrorZ_free(_res: number): void {
13803 if(!isWasmInitialized) {
13804 throw new Error("initializeWasm() must be awaited first!");
13806 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_free(_res);
13807 // debug statements here
13809 // uintptr_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg);
13811 export function CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg: number): number {
13812 if(!isWasmInitialized) {
13813 throw new Error("initializeWasm() must be awaited first!");
13815 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg);
13816 return nativeResponseValue;
13818 // struct LDKCResult_ChannelReadyDecodeErrorZ CResult_ChannelReadyDecodeErrorZ_clone(const struct LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR orig);
13820 export function CResult_ChannelReadyDecodeErrorZ_clone(orig: number): number {
13821 if(!isWasmInitialized) {
13822 throw new Error("initializeWasm() must be awaited first!");
13824 const nativeResponseValue = wasm.TS_CResult_ChannelReadyDecodeErrorZ_clone(orig);
13825 return nativeResponseValue;
13827 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
13829 export function CResult_InitDecodeErrorZ_ok(o: number): number {
13830 if(!isWasmInitialized) {
13831 throw new Error("initializeWasm() must be awaited first!");
13833 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_ok(o);
13834 return nativeResponseValue;
13836 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
13838 export function CResult_InitDecodeErrorZ_err(e: number): number {
13839 if(!isWasmInitialized) {
13840 throw new Error("initializeWasm() must be awaited first!");
13842 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_err(e);
13843 return nativeResponseValue;
13845 // bool CResult_InitDecodeErrorZ_is_ok(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR o);
13847 export function CResult_InitDecodeErrorZ_is_ok(o: number): boolean {
13848 if(!isWasmInitialized) {
13849 throw new Error("initializeWasm() must be awaited first!");
13851 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_is_ok(o);
13852 return nativeResponseValue;
13854 // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
13856 export function CResult_InitDecodeErrorZ_free(_res: number): void {
13857 if(!isWasmInitialized) {
13858 throw new Error("initializeWasm() must be awaited first!");
13860 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_free(_res);
13861 // debug statements here
13863 // uintptr_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg);
13865 export function CResult_InitDecodeErrorZ_clone_ptr(arg: number): number {
13866 if(!isWasmInitialized) {
13867 throw new Error("initializeWasm() must be awaited first!");
13869 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone_ptr(arg);
13870 return nativeResponseValue;
13872 // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
13874 export function CResult_InitDecodeErrorZ_clone(orig: number): number {
13875 if(!isWasmInitialized) {
13876 throw new Error("initializeWasm() must be awaited first!");
13878 const nativeResponseValue = wasm.TS_CResult_InitDecodeErrorZ_clone(orig);
13879 return nativeResponseValue;
13881 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
13883 export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
13884 if(!isWasmInitialized) {
13885 throw new Error("initializeWasm() must be awaited first!");
13887 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_ok(o);
13888 return nativeResponseValue;
13890 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
13892 export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
13893 if(!isWasmInitialized) {
13894 throw new Error("initializeWasm() must be awaited first!");
13896 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_err(e);
13897 return nativeResponseValue;
13899 // bool CResult_OpenChannelDecodeErrorZ_is_ok(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR o);
13901 export function CResult_OpenChannelDecodeErrorZ_is_ok(o: number): boolean {
13902 if(!isWasmInitialized) {
13903 throw new Error("initializeWasm() must be awaited first!");
13905 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_is_ok(o);
13906 return nativeResponseValue;
13908 // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
13910 export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
13911 if(!isWasmInitialized) {
13912 throw new Error("initializeWasm() must be awaited first!");
13914 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_free(_res);
13915 // debug statements here
13917 // uintptr_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg);
13919 export function CResult_OpenChannelDecodeErrorZ_clone_ptr(arg: number): number {
13920 if(!isWasmInitialized) {
13921 throw new Error("initializeWasm() must be awaited first!");
13923 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(arg);
13924 return nativeResponseValue;
13926 // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
13928 export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
13929 if(!isWasmInitialized) {
13930 throw new Error("initializeWasm() must be awaited first!");
13932 const nativeResponseValue = wasm.TS_CResult_OpenChannelDecodeErrorZ_clone(orig);
13933 return nativeResponseValue;
13935 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
13937 export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
13938 if(!isWasmInitialized) {
13939 throw new Error("initializeWasm() must be awaited first!");
13941 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_ok(o);
13942 return nativeResponseValue;
13944 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
13946 export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
13947 if(!isWasmInitialized) {
13948 throw new Error("initializeWasm() must be awaited first!");
13950 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_err(e);
13951 return nativeResponseValue;
13953 // bool CResult_RevokeAndACKDecodeErrorZ_is_ok(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR o);
13955 export function CResult_RevokeAndACKDecodeErrorZ_is_ok(o: number): boolean {
13956 if(!isWasmInitialized) {
13957 throw new Error("initializeWasm() must be awaited first!");
13959 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(o);
13960 return nativeResponseValue;
13962 // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
13964 export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
13965 if(!isWasmInitialized) {
13966 throw new Error("initializeWasm() must be awaited first!");
13968 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_free(_res);
13969 // debug statements here
13971 // uintptr_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg);
13973 export function CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg: number): number {
13974 if(!isWasmInitialized) {
13975 throw new Error("initializeWasm() must be awaited first!");
13977 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg);
13978 return nativeResponseValue;
13980 // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
13982 export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
13983 if(!isWasmInitialized) {
13984 throw new Error("initializeWasm() must be awaited first!");
13986 const nativeResponseValue = wasm.TS_CResult_RevokeAndACKDecodeErrorZ_clone(orig);
13987 return nativeResponseValue;
13989 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
13991 export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
13992 if(!isWasmInitialized) {
13993 throw new Error("initializeWasm() must be awaited first!");
13995 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_ok(o);
13996 return nativeResponseValue;
13998 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
14000 export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
14001 if(!isWasmInitialized) {
14002 throw new Error("initializeWasm() must be awaited first!");
14004 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_err(e);
14005 return nativeResponseValue;
14007 // bool CResult_ShutdownDecodeErrorZ_is_ok(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR o);
14009 export function CResult_ShutdownDecodeErrorZ_is_ok(o: number): boolean {
14010 if(!isWasmInitialized) {
14011 throw new Error("initializeWasm() must be awaited first!");
14013 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_is_ok(o);
14014 return nativeResponseValue;
14016 // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
14018 export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
14019 if(!isWasmInitialized) {
14020 throw new Error("initializeWasm() must be awaited first!");
14022 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_free(_res);
14023 // debug statements here
14025 // uintptr_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg);
14027 export function CResult_ShutdownDecodeErrorZ_clone_ptr(arg: number): number {
14028 if(!isWasmInitialized) {
14029 throw new Error("initializeWasm() must be awaited first!");
14031 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone_ptr(arg);
14032 return nativeResponseValue;
14034 // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
14036 export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
14037 if(!isWasmInitialized) {
14038 throw new Error("initializeWasm() must be awaited first!");
14040 const nativeResponseValue = wasm.TS_CResult_ShutdownDecodeErrorZ_clone(orig);
14041 return nativeResponseValue;
14043 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
14045 export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
14046 if(!isWasmInitialized) {
14047 throw new Error("initializeWasm() must be awaited first!");
14049 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
14050 return nativeResponseValue;
14052 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14054 export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
14055 if(!isWasmInitialized) {
14056 throw new Error("initializeWasm() must be awaited first!");
14058 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_err(e);
14059 return nativeResponseValue;
14061 // bool CResult_UpdateFailHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR o);
14063 export function CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o: number): boolean {
14064 if(!isWasmInitialized) {
14065 throw new Error("initializeWasm() must be awaited first!");
14067 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o);
14068 return nativeResponseValue;
14070 // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
14072 export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
14073 if(!isWasmInitialized) {
14074 throw new Error("initializeWasm() must be awaited first!");
14076 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
14077 // debug statements here
14079 // uintptr_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg);
14081 export function CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14082 if(!isWasmInitialized) {
14083 throw new Error("initializeWasm() must be awaited first!");
14085 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg);
14086 return nativeResponseValue;
14088 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
14090 export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
14091 if(!isWasmInitialized) {
14092 throw new Error("initializeWasm() must be awaited first!");
14094 const nativeResponseValue = wasm.TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
14095 return nativeResponseValue;
14097 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
14099 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
14100 if(!isWasmInitialized) {
14101 throw new Error("initializeWasm() must be awaited first!");
14103 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
14104 return nativeResponseValue;
14106 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14108 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
14109 if(!isWasmInitialized) {
14110 throw new Error("initializeWasm() must be awaited first!");
14112 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
14113 return nativeResponseValue;
14115 // bool CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR o);
14117 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o: number): boolean {
14118 if(!isWasmInitialized) {
14119 throw new Error("initializeWasm() must be awaited first!");
14121 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o);
14122 return nativeResponseValue;
14124 // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
14126 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
14127 if(!isWasmInitialized) {
14128 throw new Error("initializeWasm() must be awaited first!");
14130 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
14131 // debug statements here
14133 // uintptr_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg);
14135 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14136 if(!isWasmInitialized) {
14137 throw new Error("initializeWasm() must be awaited first!");
14139 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg);
14140 return nativeResponseValue;
14142 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
14144 export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
14145 if(!isWasmInitialized) {
14146 throw new Error("initializeWasm() must be awaited first!");
14148 const nativeResponseValue = wasm.TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
14149 return nativeResponseValue;
14151 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
14153 export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
14154 if(!isWasmInitialized) {
14155 throw new Error("initializeWasm() must be awaited first!");
14157 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_ok(o);
14158 return nativeResponseValue;
14160 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
14162 export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
14163 if(!isWasmInitialized) {
14164 throw new Error("initializeWasm() must be awaited first!");
14166 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_err(e);
14167 return nativeResponseValue;
14169 // bool CResult_UpdateFeeDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR o);
14171 export function CResult_UpdateFeeDecodeErrorZ_is_ok(o: number): boolean {
14172 if(!isWasmInitialized) {
14173 throw new Error("initializeWasm() must be awaited first!");
14175 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_is_ok(o);
14176 return nativeResponseValue;
14178 // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
14180 export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
14181 if(!isWasmInitialized) {
14182 throw new Error("initializeWasm() must be awaited first!");
14184 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_free(_res);
14185 // debug statements here
14187 // uintptr_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg);
14189 export function CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg: number): number {
14190 if(!isWasmInitialized) {
14191 throw new Error("initializeWasm() must be awaited first!");
14193 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg);
14194 return nativeResponseValue;
14196 // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
14198 export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
14199 if(!isWasmInitialized) {
14200 throw new Error("initializeWasm() must be awaited first!");
14202 const nativeResponseValue = wasm.TS_CResult_UpdateFeeDecodeErrorZ_clone(orig);
14203 return nativeResponseValue;
14205 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
14207 export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
14208 if(!isWasmInitialized) {
14209 throw new Error("initializeWasm() must be awaited first!");
14211 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
14212 return nativeResponseValue;
14214 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14216 export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
14217 if(!isWasmInitialized) {
14218 throw new Error("initializeWasm() must be awaited first!");
14220 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
14221 return nativeResponseValue;
14223 // bool CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR o);
14225 export function CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o: number): boolean {
14226 if(!isWasmInitialized) {
14227 throw new Error("initializeWasm() must be awaited first!");
14229 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o);
14230 return nativeResponseValue;
14232 // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
14234 export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
14235 if(!isWasmInitialized) {
14236 throw new Error("initializeWasm() must be awaited first!");
14238 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
14239 // debug statements here
14241 // uintptr_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg);
14243 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14244 if(!isWasmInitialized) {
14245 throw new Error("initializeWasm() must be awaited first!");
14247 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg);
14248 return nativeResponseValue;
14250 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
14252 export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
14253 if(!isWasmInitialized) {
14254 throw new Error("initializeWasm() must be awaited first!");
14256 const nativeResponseValue = wasm.TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
14257 return nativeResponseValue;
14259 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
14261 export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
14262 if(!isWasmInitialized) {
14263 throw new Error("initializeWasm() must be awaited first!");
14265 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
14266 return nativeResponseValue;
14268 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
14270 export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
14271 if(!isWasmInitialized) {
14272 throw new Error("initializeWasm() must be awaited first!");
14274 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_err(e);
14275 return nativeResponseValue;
14277 // bool CResult_UpdateAddHTLCDecodeErrorZ_is_ok(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR o);
14279 export function CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o: number): boolean {
14280 if(!isWasmInitialized) {
14281 throw new Error("initializeWasm() must be awaited first!");
14283 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o);
14284 return nativeResponseValue;
14286 // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
14288 export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
14289 if(!isWasmInitialized) {
14290 throw new Error("initializeWasm() must be awaited first!");
14292 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
14293 // debug statements here
14295 // uintptr_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg);
14297 export function CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg: number): number {
14298 if(!isWasmInitialized) {
14299 throw new Error("initializeWasm() must be awaited first!");
14301 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg);
14302 return nativeResponseValue;
14304 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
14306 export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
14307 if(!isWasmInitialized) {
14308 throw new Error("initializeWasm() must be awaited first!");
14310 const nativeResponseValue = wasm.TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
14311 return nativeResponseValue;
14313 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
14315 export function CResult_PingDecodeErrorZ_ok(o: number): number {
14316 if(!isWasmInitialized) {
14317 throw new Error("initializeWasm() must be awaited first!");
14319 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_ok(o);
14320 return nativeResponseValue;
14322 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
14324 export function CResult_PingDecodeErrorZ_err(e: number): number {
14325 if(!isWasmInitialized) {
14326 throw new Error("initializeWasm() must be awaited first!");
14328 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_err(e);
14329 return nativeResponseValue;
14331 // bool CResult_PingDecodeErrorZ_is_ok(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR o);
14333 export function CResult_PingDecodeErrorZ_is_ok(o: number): boolean {
14334 if(!isWasmInitialized) {
14335 throw new Error("initializeWasm() must be awaited first!");
14337 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_is_ok(o);
14338 return nativeResponseValue;
14340 // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
14342 export function CResult_PingDecodeErrorZ_free(_res: number): void {
14343 if(!isWasmInitialized) {
14344 throw new Error("initializeWasm() must be awaited first!");
14346 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_free(_res);
14347 // debug statements here
14349 // uintptr_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg);
14351 export function CResult_PingDecodeErrorZ_clone_ptr(arg: number): number {
14352 if(!isWasmInitialized) {
14353 throw new Error("initializeWasm() must be awaited first!");
14355 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone_ptr(arg);
14356 return nativeResponseValue;
14358 // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
14360 export function CResult_PingDecodeErrorZ_clone(orig: number): number {
14361 if(!isWasmInitialized) {
14362 throw new Error("initializeWasm() must be awaited first!");
14364 const nativeResponseValue = wasm.TS_CResult_PingDecodeErrorZ_clone(orig);
14365 return nativeResponseValue;
14367 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
14369 export function CResult_PongDecodeErrorZ_ok(o: number): number {
14370 if(!isWasmInitialized) {
14371 throw new Error("initializeWasm() must be awaited first!");
14373 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_ok(o);
14374 return nativeResponseValue;
14376 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
14378 export function CResult_PongDecodeErrorZ_err(e: number): number {
14379 if(!isWasmInitialized) {
14380 throw new Error("initializeWasm() must be awaited first!");
14382 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_err(e);
14383 return nativeResponseValue;
14385 // bool CResult_PongDecodeErrorZ_is_ok(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR o);
14387 export function CResult_PongDecodeErrorZ_is_ok(o: number): boolean {
14388 if(!isWasmInitialized) {
14389 throw new Error("initializeWasm() must be awaited first!");
14391 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_is_ok(o);
14392 return nativeResponseValue;
14394 // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
14396 export function CResult_PongDecodeErrorZ_free(_res: number): void {
14397 if(!isWasmInitialized) {
14398 throw new Error("initializeWasm() must be awaited first!");
14400 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_free(_res);
14401 // debug statements here
14403 // uintptr_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg);
14405 export function CResult_PongDecodeErrorZ_clone_ptr(arg: number): number {
14406 if(!isWasmInitialized) {
14407 throw new Error("initializeWasm() must be awaited first!");
14409 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone_ptr(arg);
14410 return nativeResponseValue;
14412 // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
14414 export function CResult_PongDecodeErrorZ_clone(orig: number): number {
14415 if(!isWasmInitialized) {
14416 throw new Error("initializeWasm() must be awaited first!");
14418 const nativeResponseValue = wasm.TS_CResult_PongDecodeErrorZ_clone(orig);
14419 return nativeResponseValue;
14421 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
14423 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
14424 if(!isWasmInitialized) {
14425 throw new Error("initializeWasm() must be awaited first!");
14427 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
14428 return nativeResponseValue;
14430 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14432 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
14433 if(!isWasmInitialized) {
14434 throw new Error("initializeWasm() must be awaited first!");
14436 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
14437 return nativeResponseValue;
14439 // bool CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14441 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14442 if(!isWasmInitialized) {
14443 throw new Error("initializeWasm() must be awaited first!");
14445 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o);
14446 return nativeResponseValue;
14448 // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
14450 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
14451 if(!isWasmInitialized) {
14452 throw new Error("initializeWasm() must be awaited first!");
14454 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
14455 // debug statements here
14457 // uintptr_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14459 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14460 if(!isWasmInitialized) {
14461 throw new Error("initializeWasm() must be awaited first!");
14463 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14464 return nativeResponseValue;
14466 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14468 export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
14469 if(!isWasmInitialized) {
14470 throw new Error("initializeWasm() must be awaited first!");
14472 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
14473 return nativeResponseValue;
14475 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
14477 export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
14478 if(!isWasmInitialized) {
14479 throw new Error("initializeWasm() must be awaited first!");
14481 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
14482 return nativeResponseValue;
14484 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14486 export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
14487 if(!isWasmInitialized) {
14488 throw new Error("initializeWasm() must be awaited first!");
14490 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_err(e);
14491 return nativeResponseValue;
14493 // bool CResult_ChannelAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR o);
14495 export function CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14496 if(!isWasmInitialized) {
14497 throw new Error("initializeWasm() must be awaited first!");
14499 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o);
14500 return nativeResponseValue;
14502 // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
14504 export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
14505 if(!isWasmInitialized) {
14506 throw new Error("initializeWasm() must be awaited first!");
14508 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
14509 // debug statements here
14511 // uintptr_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14513 export function CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14514 if(!isWasmInitialized) {
14515 throw new Error("initializeWasm() must be awaited first!");
14517 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg);
14518 return nativeResponseValue;
14520 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14522 export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
14523 if(!isWasmInitialized) {
14524 throw new Error("initializeWasm() must be awaited first!");
14526 const nativeResponseValue = wasm.TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
14527 return nativeResponseValue;
14529 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
14531 export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
14532 if(!isWasmInitialized) {
14533 throw new Error("initializeWasm() must be awaited first!");
14535 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
14536 return nativeResponseValue;
14538 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14540 export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
14541 if(!isWasmInitialized) {
14542 throw new Error("initializeWasm() must be awaited first!");
14544 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
14545 return nativeResponseValue;
14547 // bool CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14549 export function CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14550 if(!isWasmInitialized) {
14551 throw new Error("initializeWasm() must be awaited first!");
14553 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o);
14554 return nativeResponseValue;
14556 // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
14558 export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
14559 if(!isWasmInitialized) {
14560 throw new Error("initializeWasm() must be awaited first!");
14562 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
14563 // debug statements here
14565 // uintptr_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14567 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14568 if(!isWasmInitialized) {
14569 throw new Error("initializeWasm() must be awaited first!");
14571 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg);
14572 return nativeResponseValue;
14574 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14576 export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
14577 if(!isWasmInitialized) {
14578 throw new Error("initializeWasm() must be awaited first!");
14580 const nativeResponseValue = wasm.TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
14581 return nativeResponseValue;
14583 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
14585 export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
14586 if(!isWasmInitialized) {
14587 throw new Error("initializeWasm() must be awaited first!");
14589 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_ok(o);
14590 return nativeResponseValue;
14592 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
14594 export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
14595 if(!isWasmInitialized) {
14596 throw new Error("initializeWasm() must be awaited first!");
14598 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_err(e);
14599 return nativeResponseValue;
14601 // bool CResult_ChannelUpdateDecodeErrorZ_is_ok(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR o);
14603 export function CResult_ChannelUpdateDecodeErrorZ_is_ok(o: number): boolean {
14604 if(!isWasmInitialized) {
14605 throw new Error("initializeWasm() must be awaited first!");
14607 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(o);
14608 return nativeResponseValue;
14610 // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
14612 export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
14613 if(!isWasmInitialized) {
14614 throw new Error("initializeWasm() must be awaited first!");
14616 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_free(_res);
14617 // debug statements here
14619 // uintptr_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg);
14621 export function CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg: number): number {
14622 if(!isWasmInitialized) {
14623 throw new Error("initializeWasm() must be awaited first!");
14625 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg);
14626 return nativeResponseValue;
14628 // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
14630 export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
14631 if(!isWasmInitialized) {
14632 throw new Error("initializeWasm() must be awaited first!");
14634 const nativeResponseValue = wasm.TS_CResult_ChannelUpdateDecodeErrorZ_clone(orig);
14635 return nativeResponseValue;
14637 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
14639 export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
14640 if(!isWasmInitialized) {
14641 throw new Error("initializeWasm() must be awaited first!");
14643 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_ok(o);
14644 return nativeResponseValue;
14646 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
14648 export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
14649 if(!isWasmInitialized) {
14650 throw new Error("initializeWasm() must be awaited first!");
14652 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_err(e);
14653 return nativeResponseValue;
14655 // bool CResult_ErrorMessageDecodeErrorZ_is_ok(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR o);
14657 export function CResult_ErrorMessageDecodeErrorZ_is_ok(o: number): boolean {
14658 if(!isWasmInitialized) {
14659 throw new Error("initializeWasm() must be awaited first!");
14661 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_is_ok(o);
14662 return nativeResponseValue;
14664 // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
14666 export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
14667 if(!isWasmInitialized) {
14668 throw new Error("initializeWasm() must be awaited first!");
14670 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_free(_res);
14671 // debug statements here
14673 // uintptr_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg);
14675 export function CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg: number): number {
14676 if(!isWasmInitialized) {
14677 throw new Error("initializeWasm() must be awaited first!");
14679 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg);
14680 return nativeResponseValue;
14682 // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
14684 export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
14685 if(!isWasmInitialized) {
14686 throw new Error("initializeWasm() must be awaited first!");
14688 const nativeResponseValue = wasm.TS_CResult_ErrorMessageDecodeErrorZ_clone(orig);
14689 return nativeResponseValue;
14691 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_ok(struct LDKWarningMessage o);
14693 export function CResult_WarningMessageDecodeErrorZ_ok(o: number): number {
14694 if(!isWasmInitialized) {
14695 throw new Error("initializeWasm() must be awaited first!");
14697 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_ok(o);
14698 return nativeResponseValue;
14700 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_err(struct LDKDecodeError e);
14702 export function CResult_WarningMessageDecodeErrorZ_err(e: number): number {
14703 if(!isWasmInitialized) {
14704 throw new Error("initializeWasm() must be awaited first!");
14706 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_err(e);
14707 return nativeResponseValue;
14709 // bool CResult_WarningMessageDecodeErrorZ_is_ok(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR o);
14711 export function CResult_WarningMessageDecodeErrorZ_is_ok(o: number): boolean {
14712 if(!isWasmInitialized) {
14713 throw new Error("initializeWasm() must be awaited first!");
14715 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_is_ok(o);
14716 return nativeResponseValue;
14718 // void CResult_WarningMessageDecodeErrorZ_free(struct LDKCResult_WarningMessageDecodeErrorZ _res);
14720 export function CResult_WarningMessageDecodeErrorZ_free(_res: number): void {
14721 if(!isWasmInitialized) {
14722 throw new Error("initializeWasm() must be awaited first!");
14724 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_free(_res);
14725 // debug statements here
14727 // uintptr_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg);
14729 export function CResult_WarningMessageDecodeErrorZ_clone_ptr(arg: number): number {
14730 if(!isWasmInitialized) {
14731 throw new Error("initializeWasm() must be awaited first!");
14733 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(arg);
14734 return nativeResponseValue;
14736 // struct LDKCResult_WarningMessageDecodeErrorZ CResult_WarningMessageDecodeErrorZ_clone(const struct LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR orig);
14738 export function CResult_WarningMessageDecodeErrorZ_clone(orig: number): number {
14739 if(!isWasmInitialized) {
14740 throw new Error("initializeWasm() must be awaited first!");
14742 const nativeResponseValue = wasm.TS_CResult_WarningMessageDecodeErrorZ_clone(orig);
14743 return nativeResponseValue;
14745 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
14747 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
14748 if(!isWasmInitialized) {
14749 throw new Error("initializeWasm() must be awaited first!");
14751 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
14752 return nativeResponseValue;
14754 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14756 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
14757 if(!isWasmInitialized) {
14758 throw new Error("initializeWasm() must be awaited first!");
14760 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
14761 return nativeResponseValue;
14763 // bool CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14765 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14766 if(!isWasmInitialized) {
14767 throw new Error("initializeWasm() must be awaited first!");
14769 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o);
14770 return nativeResponseValue;
14772 // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
14774 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
14775 if(!isWasmInitialized) {
14776 throw new Error("initializeWasm() must be awaited first!");
14778 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
14779 // debug statements here
14781 // uintptr_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14783 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14784 if(!isWasmInitialized) {
14785 throw new Error("initializeWasm() must be awaited first!");
14787 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14788 return nativeResponseValue;
14790 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14792 export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14793 if(!isWasmInitialized) {
14794 throw new Error("initializeWasm() must be awaited first!");
14796 const nativeResponseValue = wasm.TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
14797 return nativeResponseValue;
14799 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
14801 export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
14802 if(!isWasmInitialized) {
14803 throw new Error("initializeWasm() must be awaited first!");
14805 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_ok(o);
14806 return nativeResponseValue;
14808 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
14810 export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
14811 if(!isWasmInitialized) {
14812 throw new Error("initializeWasm() must be awaited first!");
14814 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_err(e);
14815 return nativeResponseValue;
14817 // bool CResult_NodeAnnouncementDecodeErrorZ_is_ok(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR o);
14819 export function CResult_NodeAnnouncementDecodeErrorZ_is_ok(o: number): boolean {
14820 if(!isWasmInitialized) {
14821 throw new Error("initializeWasm() must be awaited first!");
14823 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(o);
14824 return nativeResponseValue;
14826 // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
14828 export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
14829 if(!isWasmInitialized) {
14830 throw new Error("initializeWasm() must be awaited first!");
14832 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_free(_res);
14833 // debug statements here
14835 // uintptr_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg);
14837 export function CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg: number): number {
14838 if(!isWasmInitialized) {
14839 throw new Error("initializeWasm() must be awaited first!");
14841 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg);
14842 return nativeResponseValue;
14844 // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
14846 export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
14847 if(!isWasmInitialized) {
14848 throw new Error("initializeWasm() must be awaited first!");
14850 const nativeResponseValue = wasm.TS_CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
14851 return nativeResponseValue;
14853 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
14855 export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
14856 if(!isWasmInitialized) {
14857 throw new Error("initializeWasm() must be awaited first!");
14859 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
14860 return nativeResponseValue;
14862 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
14864 export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
14865 if(!isWasmInitialized) {
14866 throw new Error("initializeWasm() must be awaited first!");
14868 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
14869 return nativeResponseValue;
14871 // bool CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR o);
14873 export function CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o: number): boolean {
14874 if(!isWasmInitialized) {
14875 throw new Error("initializeWasm() must be awaited first!");
14877 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o);
14878 return nativeResponseValue;
14880 // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
14882 export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
14883 if(!isWasmInitialized) {
14884 throw new Error("initializeWasm() must be awaited first!");
14886 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
14887 // debug statements here
14889 // uintptr_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg);
14891 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg: number): number {
14892 if(!isWasmInitialized) {
14893 throw new Error("initializeWasm() must be awaited first!");
14895 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg);
14896 return nativeResponseValue;
14898 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
14900 export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
14901 if(!isWasmInitialized) {
14902 throw new Error("initializeWasm() must be awaited first!");
14904 const nativeResponseValue = wasm.TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
14905 return nativeResponseValue;
14907 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
14909 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
14910 if(!isWasmInitialized) {
14911 throw new Error("initializeWasm() must be awaited first!");
14913 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
14914 return nativeResponseValue;
14916 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
14918 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
14919 if(!isWasmInitialized) {
14920 throw new Error("initializeWasm() must be awaited first!");
14922 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
14923 return nativeResponseValue;
14925 // bool CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR o);
14927 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o: number): boolean {
14928 if(!isWasmInitialized) {
14929 throw new Error("initializeWasm() must be awaited first!");
14931 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o);
14932 return nativeResponseValue;
14934 // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
14936 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
14937 if(!isWasmInitialized) {
14938 throw new Error("initializeWasm() must be awaited first!");
14940 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
14941 // debug statements here
14943 // uintptr_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg);
14945 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg: number): number {
14946 if(!isWasmInitialized) {
14947 throw new Error("initializeWasm() must be awaited first!");
14949 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg);
14950 return nativeResponseValue;
14952 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
14954 export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
14955 if(!isWasmInitialized) {
14956 throw new Error("initializeWasm() must be awaited first!");
14958 const nativeResponseValue = wasm.TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
14959 return nativeResponseValue;
14961 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
14963 export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
14964 if(!isWasmInitialized) {
14965 throw new Error("initializeWasm() must be awaited first!");
14967 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_ok(o);
14968 return nativeResponseValue;
14970 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
14972 export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
14973 if(!isWasmInitialized) {
14974 throw new Error("initializeWasm() must be awaited first!");
14976 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_err(e);
14977 return nativeResponseValue;
14979 // bool CResult_QueryChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR o);
14981 export function CResult_QueryChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
14982 if(!isWasmInitialized) {
14983 throw new Error("initializeWasm() must be awaited first!");
14985 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(o);
14986 return nativeResponseValue;
14988 // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
14990 export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
14991 if(!isWasmInitialized) {
14992 throw new Error("initializeWasm() must be awaited first!");
14994 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_free(_res);
14995 // debug statements here
14997 // uintptr_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg);
14999 export function CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
15000 if(!isWasmInitialized) {
15001 throw new Error("initializeWasm() must be awaited first!");
15003 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg);
15004 return nativeResponseValue;
15006 // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
15008 export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
15009 if(!isWasmInitialized) {
15010 throw new Error("initializeWasm() must be awaited first!");
15012 const nativeResponseValue = wasm.TS_CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
15013 return nativeResponseValue;
15015 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
15017 export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
15018 if(!isWasmInitialized) {
15019 throw new Error("initializeWasm() must be awaited first!");
15021 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
15022 return nativeResponseValue;
15024 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
15026 export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
15027 if(!isWasmInitialized) {
15028 throw new Error("initializeWasm() must be awaited first!");
15030 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_err(e);
15031 return nativeResponseValue;
15033 // bool CResult_ReplyChannelRangeDecodeErrorZ_is_ok(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR o);
15035 export function CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o: number): boolean {
15036 if(!isWasmInitialized) {
15037 throw new Error("initializeWasm() must be awaited first!");
15039 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o);
15040 return nativeResponseValue;
15042 // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
15044 export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
15045 if(!isWasmInitialized) {
15046 throw new Error("initializeWasm() must be awaited first!");
15048 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
15049 // debug statements here
15051 // uintptr_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg);
15053 export function CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg: number): number {
15054 if(!isWasmInitialized) {
15055 throw new Error("initializeWasm() must be awaited first!");
15057 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg);
15058 return nativeResponseValue;
15060 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
15062 export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
15063 if(!isWasmInitialized) {
15064 throw new Error("initializeWasm() must be awaited first!");
15066 const nativeResponseValue = wasm.TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
15067 return nativeResponseValue;
15069 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
15071 export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
15072 if(!isWasmInitialized) {
15073 throw new Error("initializeWasm() must be awaited first!");
15075 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
15076 return nativeResponseValue;
15078 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
15080 export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
15081 if(!isWasmInitialized) {
15082 throw new Error("initializeWasm() must be awaited first!");
15084 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_err(e);
15085 return nativeResponseValue;
15087 // bool CResult_GossipTimestampFilterDecodeErrorZ_is_ok(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR o);
15089 export function CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o: number): boolean {
15090 if(!isWasmInitialized) {
15091 throw new Error("initializeWasm() must be awaited first!");
15093 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o);
15094 return nativeResponseValue;
15096 // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
15098 export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
15099 if(!isWasmInitialized) {
15100 throw new Error("initializeWasm() must be awaited first!");
15102 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
15103 // debug statements here
15105 // uintptr_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg);
15107 export function CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg: number): number {
15108 if(!isWasmInitialized) {
15109 throw new Error("initializeWasm() must be awaited first!");
15111 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg);
15112 return nativeResponseValue;
15114 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
15116 export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
15117 if(!isWasmInitialized) {
15118 throw new Error("initializeWasm() must be awaited first!");
15120 const nativeResponseValue = wasm.TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
15121 return nativeResponseValue;
15123 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_ok(struct LDKInvoice o);
15125 export function CResult_InvoiceSignOrCreationErrorZ_ok(o: number): number {
15126 if(!isWasmInitialized) {
15127 throw new Error("initializeWasm() must be awaited first!");
15129 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_ok(o);
15130 return nativeResponseValue;
15132 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_err(struct LDKSignOrCreationError e);
15134 export function CResult_InvoiceSignOrCreationErrorZ_err(e: number): number {
15135 if(!isWasmInitialized) {
15136 throw new Error("initializeWasm() must be awaited first!");
15138 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_err(e);
15139 return nativeResponseValue;
15141 // bool CResult_InvoiceSignOrCreationErrorZ_is_ok(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR o);
15143 export function CResult_InvoiceSignOrCreationErrorZ_is_ok(o: number): boolean {
15144 if(!isWasmInitialized) {
15145 throw new Error("initializeWasm() must be awaited first!");
15147 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(o);
15148 return nativeResponseValue;
15150 // void CResult_InvoiceSignOrCreationErrorZ_free(struct LDKCResult_InvoiceSignOrCreationErrorZ _res);
15152 export function CResult_InvoiceSignOrCreationErrorZ_free(_res: number): void {
15153 if(!isWasmInitialized) {
15154 throw new Error("initializeWasm() must be awaited first!");
15156 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_free(_res);
15157 // debug statements here
15159 // uintptr_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg);
15161 export function CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg: number): number {
15162 if(!isWasmInitialized) {
15163 throw new Error("initializeWasm() must be awaited first!");
15165 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg);
15166 return nativeResponseValue;
15168 // struct LDKCResult_InvoiceSignOrCreationErrorZ CResult_InvoiceSignOrCreationErrorZ_clone(const struct LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR orig);
15170 export function CResult_InvoiceSignOrCreationErrorZ_clone(orig: number): number {
15171 if(!isWasmInitialized) {
15172 throw new Error("initializeWasm() must be awaited first!");
15174 const nativeResponseValue = wasm.TS_CResult_InvoiceSignOrCreationErrorZ_clone(orig);
15175 return nativeResponseValue;
15177 // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
15179 export function COption_FilterZ_some(o: number): number {
15180 if(!isWasmInitialized) {
15181 throw new Error("initializeWasm() must be awaited first!");
15183 const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
15184 return nativeResponseValue;
15186 // struct LDKCOption_FilterZ COption_FilterZ_none(void);
15188 export function COption_FilterZ_none(): number {
15189 if(!isWasmInitialized) {
15190 throw new Error("initializeWasm() must be awaited first!");
15192 const nativeResponseValue = wasm.TS_COption_FilterZ_none();
15193 return nativeResponseValue;
15195 // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
15197 export function COption_FilterZ_free(_res: number): void {
15198 if(!isWasmInitialized) {
15199 throw new Error("initializeWasm() must be awaited first!");
15201 const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
15202 // debug statements here
15204 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
15206 export function CResult_LockedChannelMonitorNoneZ_ok(o: number): number {
15207 if(!isWasmInitialized) {
15208 throw new Error("initializeWasm() must be awaited first!");
15210 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
15211 return nativeResponseValue;
15213 // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
15215 export function CResult_LockedChannelMonitorNoneZ_err(): number {
15216 if(!isWasmInitialized) {
15217 throw new Error("initializeWasm() must be awaited first!");
15219 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
15220 return nativeResponseValue;
15222 // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
15224 export function CResult_LockedChannelMonitorNoneZ_is_ok(o: number): boolean {
15225 if(!isWasmInitialized) {
15226 throw new Error("initializeWasm() must be awaited first!");
15228 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
15229 return nativeResponseValue;
15231 // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
15233 export function CResult_LockedChannelMonitorNoneZ_free(_res: number): void {
15234 if(!isWasmInitialized) {
15235 throw new Error("initializeWasm() must be awaited first!");
15237 const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
15238 // debug statements here
15240 // void CVec_OutPointZ_free(struct LDKCVec_OutPointZ _res);
15242 export function CVec_OutPointZ_free(_res: number): void {
15243 if(!isWasmInitialized) {
15244 throw new Error("initializeWasm() must be awaited first!");
15246 const nativeResponseValue = wasm.TS_CVec_OutPointZ_free(_res);
15247 // debug statements here
15249 // void PaymentPurpose_free(struct LDKPaymentPurpose this_ptr);
15251 export function PaymentPurpose_free(this_ptr: number): void {
15252 if(!isWasmInitialized) {
15253 throw new Error("initializeWasm() must be awaited first!");
15255 const nativeResponseValue = wasm.TS_PaymentPurpose_free(this_ptr);
15256 // debug statements here
15258 // uintptr_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg);
15260 export function PaymentPurpose_clone_ptr(arg: number): number {
15261 if(!isWasmInitialized) {
15262 throw new Error("initializeWasm() must be awaited first!");
15264 const nativeResponseValue = wasm.TS_PaymentPurpose_clone_ptr(arg);
15265 return nativeResponseValue;
15267 // struct LDKPaymentPurpose PaymentPurpose_clone(const struct LDKPaymentPurpose *NONNULL_PTR orig);
15269 export function PaymentPurpose_clone(orig: number): number {
15270 if(!isWasmInitialized) {
15271 throw new Error("initializeWasm() must be awaited first!");
15273 const nativeResponseValue = wasm.TS_PaymentPurpose_clone(orig);
15274 return nativeResponseValue;
15276 // struct LDKPaymentPurpose PaymentPurpose_invoice_payment(struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_secret);
15278 export function PaymentPurpose_invoice_payment(payment_preimage: number, payment_secret: number): number {
15279 if(!isWasmInitialized) {
15280 throw new Error("initializeWasm() must be awaited first!");
15282 const nativeResponseValue = wasm.TS_PaymentPurpose_invoice_payment(payment_preimage, payment_secret);
15283 return nativeResponseValue;
15285 // struct LDKPaymentPurpose PaymentPurpose_spontaneous_payment(struct LDKThirtyTwoBytes a);
15287 export function PaymentPurpose_spontaneous_payment(a: number): number {
15288 if(!isWasmInitialized) {
15289 throw new Error("initializeWasm() must be awaited first!");
15291 const nativeResponseValue = wasm.TS_PaymentPurpose_spontaneous_payment(a);
15292 return nativeResponseValue;
15294 // struct LDKCVec_u8Z PaymentPurpose_write(const struct LDKPaymentPurpose *NONNULL_PTR obj);
15296 export function PaymentPurpose_write(obj: number): number {
15297 if(!isWasmInitialized) {
15298 throw new Error("initializeWasm() must be awaited first!");
15300 const nativeResponseValue = wasm.TS_PaymentPurpose_write(obj);
15301 return nativeResponseValue;
15303 // struct LDKCResult_PaymentPurposeDecodeErrorZ PaymentPurpose_read(struct LDKu8slice ser);
15305 export function PaymentPurpose_read(ser: number): number {
15306 if(!isWasmInitialized) {
15307 throw new Error("initializeWasm() must be awaited first!");
15309 const nativeResponseValue = wasm.TS_PaymentPurpose_read(ser);
15310 return nativeResponseValue;
15312 // void ClosureReason_free(struct LDKClosureReason this_ptr);
15314 export function ClosureReason_free(this_ptr: number): void {
15315 if(!isWasmInitialized) {
15316 throw new Error("initializeWasm() must be awaited first!");
15318 const nativeResponseValue = wasm.TS_ClosureReason_free(this_ptr);
15319 // debug statements here
15321 // uintptr_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg);
15323 export function ClosureReason_clone_ptr(arg: number): number {
15324 if(!isWasmInitialized) {
15325 throw new Error("initializeWasm() must be awaited first!");
15327 const nativeResponseValue = wasm.TS_ClosureReason_clone_ptr(arg);
15328 return nativeResponseValue;
15330 // struct LDKClosureReason ClosureReason_clone(const struct LDKClosureReason *NONNULL_PTR orig);
15332 export function ClosureReason_clone(orig: number): number {
15333 if(!isWasmInitialized) {
15334 throw new Error("initializeWasm() must be awaited first!");
15336 const nativeResponseValue = wasm.TS_ClosureReason_clone(orig);
15337 return nativeResponseValue;
15339 // struct LDKClosureReason ClosureReason_counterparty_force_closed(struct LDKStr peer_msg);
15341 export function ClosureReason_counterparty_force_closed(peer_msg: number): number {
15342 if(!isWasmInitialized) {
15343 throw new Error("initializeWasm() must be awaited first!");
15345 const nativeResponseValue = wasm.TS_ClosureReason_counterparty_force_closed(peer_msg);
15346 return nativeResponseValue;
15348 // struct LDKClosureReason ClosureReason_holder_force_closed(void);
15350 export function ClosureReason_holder_force_closed(): number {
15351 if(!isWasmInitialized) {
15352 throw new Error("initializeWasm() must be awaited first!");
15354 const nativeResponseValue = wasm.TS_ClosureReason_holder_force_closed();
15355 return nativeResponseValue;
15357 // struct LDKClosureReason ClosureReason_cooperative_closure(void);
15359 export function ClosureReason_cooperative_closure(): number {
15360 if(!isWasmInitialized) {
15361 throw new Error("initializeWasm() must be awaited first!");
15363 const nativeResponseValue = wasm.TS_ClosureReason_cooperative_closure();
15364 return nativeResponseValue;
15366 // struct LDKClosureReason ClosureReason_commitment_tx_confirmed(void);
15368 export function ClosureReason_commitment_tx_confirmed(): number {
15369 if(!isWasmInitialized) {
15370 throw new Error("initializeWasm() must be awaited first!");
15372 const nativeResponseValue = wasm.TS_ClosureReason_commitment_tx_confirmed();
15373 return nativeResponseValue;
15375 // struct LDKClosureReason ClosureReason_funding_timed_out(void);
15377 export function ClosureReason_funding_timed_out(): number {
15378 if(!isWasmInitialized) {
15379 throw new Error("initializeWasm() must be awaited first!");
15381 const nativeResponseValue = wasm.TS_ClosureReason_funding_timed_out();
15382 return nativeResponseValue;
15384 // struct LDKClosureReason ClosureReason_processing_error(struct LDKStr err);
15386 export function ClosureReason_processing_error(err: number): number {
15387 if(!isWasmInitialized) {
15388 throw new Error("initializeWasm() must be awaited first!");
15390 const nativeResponseValue = wasm.TS_ClosureReason_processing_error(err);
15391 return nativeResponseValue;
15393 // struct LDKClosureReason ClosureReason_disconnected_peer(void);
15395 export function ClosureReason_disconnected_peer(): number {
15396 if(!isWasmInitialized) {
15397 throw new Error("initializeWasm() must be awaited first!");
15399 const nativeResponseValue = wasm.TS_ClosureReason_disconnected_peer();
15400 return nativeResponseValue;
15402 // struct LDKClosureReason ClosureReason_outdated_channel_manager(void);
15404 export function ClosureReason_outdated_channel_manager(): number {
15405 if(!isWasmInitialized) {
15406 throw new Error("initializeWasm() must be awaited first!");
15408 const nativeResponseValue = wasm.TS_ClosureReason_outdated_channel_manager();
15409 return nativeResponseValue;
15411 // struct LDKCVec_u8Z ClosureReason_write(const struct LDKClosureReason *NONNULL_PTR obj);
15413 export function ClosureReason_write(obj: number): number {
15414 if(!isWasmInitialized) {
15415 throw new Error("initializeWasm() must be awaited first!");
15417 const nativeResponseValue = wasm.TS_ClosureReason_write(obj);
15418 return nativeResponseValue;
15420 // struct LDKCResult_COption_ClosureReasonZDecodeErrorZ ClosureReason_read(struct LDKu8slice ser);
15422 export function ClosureReason_read(ser: number): number {
15423 if(!isWasmInitialized) {
15424 throw new Error("initializeWasm() must be awaited first!");
15426 const nativeResponseValue = wasm.TS_ClosureReason_read(ser);
15427 return nativeResponseValue;
15429 // void Event_free(struct LDKEvent this_ptr);
15431 export function Event_free(this_ptr: number): void {
15432 if(!isWasmInitialized) {
15433 throw new Error("initializeWasm() must be awaited first!");
15435 const nativeResponseValue = wasm.TS_Event_free(this_ptr);
15436 // debug statements here
15438 // uintptr_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg);
15440 export function Event_clone_ptr(arg: number): number {
15441 if(!isWasmInitialized) {
15442 throw new Error("initializeWasm() must be awaited first!");
15444 const nativeResponseValue = wasm.TS_Event_clone_ptr(arg);
15445 return nativeResponseValue;
15447 // struct LDKEvent Event_clone(const struct LDKEvent *NONNULL_PTR orig);
15449 export function Event_clone(orig: number): number {
15450 if(!isWasmInitialized) {
15451 throw new Error("initializeWasm() must be awaited first!");
15453 const nativeResponseValue = wasm.TS_Event_clone(orig);
15454 return nativeResponseValue;
15456 // 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);
15458 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 {
15459 if(!isWasmInitialized) {
15460 throw new Error("initializeWasm() must be awaited first!");
15462 const nativeResponseValue = wasm.TS_Event_funding_generation_ready(temporary_channel_id, counterparty_node_id, channel_value_satoshis, output_script, user_channel_id);
15463 return nativeResponseValue;
15465 // struct LDKEvent Event_payment_received(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15467 export function Event_payment_received(payment_hash: number, amount_msat: bigint, purpose: number): number {
15468 if(!isWasmInitialized) {
15469 throw new Error("initializeWasm() must be awaited first!");
15471 const nativeResponseValue = wasm.TS_Event_payment_received(payment_hash, amount_msat, purpose);
15472 return nativeResponseValue;
15474 // struct LDKEvent Event_payment_claimed(struct LDKThirtyTwoBytes payment_hash, uint64_t amount_msat, struct LDKPaymentPurpose purpose);
15476 export function Event_payment_claimed(payment_hash: number, amount_msat: bigint, purpose: number): number {
15477 if(!isWasmInitialized) {
15478 throw new Error("initializeWasm() must be awaited first!");
15480 const nativeResponseValue = wasm.TS_Event_payment_claimed(payment_hash, amount_msat, purpose);
15481 return nativeResponseValue;
15483 // struct LDKEvent Event_payment_sent(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_preimage, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u64Z fee_paid_msat);
15485 export function Event_payment_sent(payment_id: number, payment_preimage: number, payment_hash: number, fee_paid_msat: number): number {
15486 if(!isWasmInitialized) {
15487 throw new Error("initializeWasm() must be awaited first!");
15489 const nativeResponseValue = wasm.TS_Event_payment_sent(payment_id, payment_preimage, payment_hash, fee_paid_msat);
15490 return nativeResponseValue;
15492 // struct LDKEvent Event_payment_failed(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash);
15494 export function Event_payment_failed(payment_id: number, payment_hash: number): number {
15495 if(!isWasmInitialized) {
15496 throw new Error("initializeWasm() must be awaited first!");
15498 const nativeResponseValue = wasm.TS_Event_payment_failed(payment_id, payment_hash);
15499 return nativeResponseValue;
15501 // struct LDKEvent Event_payment_path_successful(struct LDKThirtyTwoBytes payment_id, struct LDKThirtyTwoBytes payment_hash, struct LDKCVec_RouteHopZ path);
15503 export function Event_payment_path_successful(payment_id: number, payment_hash: number, path: number): number {
15504 if(!isWasmInitialized) {
15505 throw new Error("initializeWasm() must be awaited first!");
15507 const nativeResponseValue = wasm.TS_Event_payment_path_successful(payment_id, payment_hash, path);
15508 return nativeResponseValue;
15510 // 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);
15512 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 {
15513 if(!isWasmInitialized) {
15514 throw new Error("initializeWasm() must be awaited first!");
15516 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);
15517 return nativeResponseValue;
15519 // struct LDKEvent Event_pending_htlcs_forwardable(uint64_t time_forwardable);
15521 export function Event_pending_htlcs_forwardable(time_forwardable: bigint): number {
15522 if(!isWasmInitialized) {
15523 throw new Error("initializeWasm() must be awaited first!");
15525 const nativeResponseValue = wasm.TS_Event_pending_htlcs_forwardable(time_forwardable);
15526 return nativeResponseValue;
15528 // struct LDKEvent Event_spendable_outputs(struct LDKCVec_SpendableOutputDescriptorZ outputs);
15530 export function Event_spendable_outputs(outputs: number): number {
15531 if(!isWasmInitialized) {
15532 throw new Error("initializeWasm() must be awaited first!");
15534 const nativeResponseValue = wasm.TS_Event_spendable_outputs(outputs);
15535 return nativeResponseValue;
15537 // 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);
15539 export function Event_payment_forwarded(prev_channel_id: number, next_channel_id: number, fee_earned_msat: number, claim_from_onchain_tx: boolean): number {
15540 if(!isWasmInitialized) {
15541 throw new Error("initializeWasm() must be awaited first!");
15543 const nativeResponseValue = wasm.TS_Event_payment_forwarded(prev_channel_id, next_channel_id, fee_earned_msat, claim_from_onchain_tx);
15544 return nativeResponseValue;
15546 // struct LDKEvent Event_channel_closed(struct LDKThirtyTwoBytes channel_id, uint64_t user_channel_id, struct LDKClosureReason reason);
15548 export function Event_channel_closed(channel_id: number, user_channel_id: bigint, reason: number): number {
15549 if(!isWasmInitialized) {
15550 throw new Error("initializeWasm() must be awaited first!");
15552 const nativeResponseValue = wasm.TS_Event_channel_closed(channel_id, user_channel_id, reason);
15553 return nativeResponseValue;
15555 // struct LDKEvent Event_discard_funding(struct LDKThirtyTwoBytes channel_id, struct LDKTransaction transaction);
15557 export function Event_discard_funding(channel_id: number, transaction: number): number {
15558 if(!isWasmInitialized) {
15559 throw new Error("initializeWasm() must be awaited first!");
15561 const nativeResponseValue = wasm.TS_Event_discard_funding(channel_id, transaction);
15562 return nativeResponseValue;
15564 // 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);
15566 export function Event_open_channel_request(temporary_channel_id: number, counterparty_node_id: number, funding_satoshis: bigint, push_msat: bigint, channel_type: number): number {
15567 if(!isWasmInitialized) {
15568 throw new Error("initializeWasm() must be awaited first!");
15570 const nativeResponseValue = wasm.TS_Event_open_channel_request(temporary_channel_id, counterparty_node_id, funding_satoshis, push_msat, channel_type);
15571 return nativeResponseValue;
15573 // struct LDKCVec_u8Z Event_write(const struct LDKEvent *NONNULL_PTR obj);
15575 export function Event_write(obj: number): number {
15576 if(!isWasmInitialized) {
15577 throw new Error("initializeWasm() must be awaited first!");
15579 const nativeResponseValue = wasm.TS_Event_write(obj);
15580 return nativeResponseValue;
15582 // struct LDKCResult_COption_EventZDecodeErrorZ Event_read(struct LDKu8slice ser);
15584 export function Event_read(ser: number): number {
15585 if(!isWasmInitialized) {
15586 throw new Error("initializeWasm() must be awaited first!");
15588 const nativeResponseValue = wasm.TS_Event_read(ser);
15589 return nativeResponseValue;
15591 // void MessageSendEvent_free(struct LDKMessageSendEvent this_ptr);
15593 export function MessageSendEvent_free(this_ptr: number): void {
15594 if(!isWasmInitialized) {
15595 throw new Error("initializeWasm() must be awaited first!");
15597 const nativeResponseValue = wasm.TS_MessageSendEvent_free(this_ptr);
15598 // debug statements here
15600 // uintptr_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg);
15602 export function MessageSendEvent_clone_ptr(arg: number): number {
15603 if(!isWasmInitialized) {
15604 throw new Error("initializeWasm() must be awaited first!");
15606 const nativeResponseValue = wasm.TS_MessageSendEvent_clone_ptr(arg);
15607 return nativeResponseValue;
15609 // struct LDKMessageSendEvent MessageSendEvent_clone(const struct LDKMessageSendEvent *NONNULL_PTR orig);
15611 export function MessageSendEvent_clone(orig: number): number {
15612 if(!isWasmInitialized) {
15613 throw new Error("initializeWasm() must be awaited first!");
15615 const nativeResponseValue = wasm.TS_MessageSendEvent_clone(orig);
15616 return nativeResponseValue;
15618 // struct LDKMessageSendEvent MessageSendEvent_send_accept_channel(struct LDKPublicKey node_id, struct LDKAcceptChannel msg);
15620 export function MessageSendEvent_send_accept_channel(node_id: number, msg: number): number {
15621 if(!isWasmInitialized) {
15622 throw new Error("initializeWasm() must be awaited first!");
15624 const nativeResponseValue = wasm.TS_MessageSendEvent_send_accept_channel(node_id, msg);
15625 return nativeResponseValue;
15627 // struct LDKMessageSendEvent MessageSendEvent_send_open_channel(struct LDKPublicKey node_id, struct LDKOpenChannel msg);
15629 export function MessageSendEvent_send_open_channel(node_id: number, msg: number): number {
15630 if(!isWasmInitialized) {
15631 throw new Error("initializeWasm() must be awaited first!");
15633 const nativeResponseValue = wasm.TS_MessageSendEvent_send_open_channel(node_id, msg);
15634 return nativeResponseValue;
15636 // struct LDKMessageSendEvent MessageSendEvent_send_funding_created(struct LDKPublicKey node_id, struct LDKFundingCreated msg);
15638 export function MessageSendEvent_send_funding_created(node_id: number, msg: number): number {
15639 if(!isWasmInitialized) {
15640 throw new Error("initializeWasm() must be awaited first!");
15642 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_created(node_id, msg);
15643 return nativeResponseValue;
15645 // struct LDKMessageSendEvent MessageSendEvent_send_funding_signed(struct LDKPublicKey node_id, struct LDKFundingSigned msg);
15647 export function MessageSendEvent_send_funding_signed(node_id: number, msg: number): number {
15648 if(!isWasmInitialized) {
15649 throw new Error("initializeWasm() must be awaited first!");
15651 const nativeResponseValue = wasm.TS_MessageSendEvent_send_funding_signed(node_id, msg);
15652 return nativeResponseValue;
15654 // struct LDKMessageSendEvent MessageSendEvent_send_channel_ready(struct LDKPublicKey node_id, struct LDKChannelReady msg);
15656 export function MessageSendEvent_send_channel_ready(node_id: number, msg: number): number {
15657 if(!isWasmInitialized) {
15658 throw new Error("initializeWasm() must be awaited first!");
15660 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_ready(node_id, msg);
15661 return nativeResponseValue;
15663 // struct LDKMessageSendEvent MessageSendEvent_send_announcement_signatures(struct LDKPublicKey node_id, struct LDKAnnouncementSignatures msg);
15665 export function MessageSendEvent_send_announcement_signatures(node_id: number, msg: number): number {
15666 if(!isWasmInitialized) {
15667 throw new Error("initializeWasm() must be awaited first!");
15669 const nativeResponseValue = wasm.TS_MessageSendEvent_send_announcement_signatures(node_id, msg);
15670 return nativeResponseValue;
15672 // struct LDKMessageSendEvent MessageSendEvent_update_htlcs(struct LDKPublicKey node_id, struct LDKCommitmentUpdate updates);
15674 export function MessageSendEvent_update_htlcs(node_id: number, updates: number): number {
15675 if(!isWasmInitialized) {
15676 throw new Error("initializeWasm() must be awaited first!");
15678 const nativeResponseValue = wasm.TS_MessageSendEvent_update_htlcs(node_id, updates);
15679 return nativeResponseValue;
15681 // struct LDKMessageSendEvent MessageSendEvent_send_revoke_and_ack(struct LDKPublicKey node_id, struct LDKRevokeAndACK msg);
15683 export function MessageSendEvent_send_revoke_and_ack(node_id: number, msg: number): number {
15684 if(!isWasmInitialized) {
15685 throw new Error("initializeWasm() must be awaited first!");
15687 const nativeResponseValue = wasm.TS_MessageSendEvent_send_revoke_and_ack(node_id, msg);
15688 return nativeResponseValue;
15690 // struct LDKMessageSendEvent MessageSendEvent_send_closing_signed(struct LDKPublicKey node_id, struct LDKClosingSigned msg);
15692 export function MessageSendEvent_send_closing_signed(node_id: number, msg: number): number {
15693 if(!isWasmInitialized) {
15694 throw new Error("initializeWasm() must be awaited first!");
15696 const nativeResponseValue = wasm.TS_MessageSendEvent_send_closing_signed(node_id, msg);
15697 return nativeResponseValue;
15699 // struct LDKMessageSendEvent MessageSendEvent_send_shutdown(struct LDKPublicKey node_id, struct LDKShutdown msg);
15701 export function MessageSendEvent_send_shutdown(node_id: number, msg: number): number {
15702 if(!isWasmInitialized) {
15703 throw new Error("initializeWasm() must be awaited first!");
15705 const nativeResponseValue = wasm.TS_MessageSendEvent_send_shutdown(node_id, msg);
15706 return nativeResponseValue;
15708 // struct LDKMessageSendEvent MessageSendEvent_send_channel_reestablish(struct LDKPublicKey node_id, struct LDKChannelReestablish msg);
15710 export function MessageSendEvent_send_channel_reestablish(node_id: number, msg: number): number {
15711 if(!isWasmInitialized) {
15712 throw new Error("initializeWasm() must be awaited first!");
15714 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_reestablish(node_id, msg);
15715 return nativeResponseValue;
15717 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_announcement(struct LDKChannelAnnouncement msg, struct LDKChannelUpdate update_msg);
15719 export function MessageSendEvent_broadcast_channel_announcement(msg: number, update_msg: number): number {
15720 if(!isWasmInitialized) {
15721 throw new Error("initializeWasm() must be awaited first!");
15723 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_announcement(msg, update_msg);
15724 return nativeResponseValue;
15726 // struct LDKMessageSendEvent MessageSendEvent_broadcast_node_announcement(struct LDKNodeAnnouncement msg);
15728 export function MessageSendEvent_broadcast_node_announcement(msg: number): number {
15729 if(!isWasmInitialized) {
15730 throw new Error("initializeWasm() must be awaited first!");
15732 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_node_announcement(msg);
15733 return nativeResponseValue;
15735 // struct LDKMessageSendEvent MessageSendEvent_broadcast_channel_update(struct LDKChannelUpdate msg);
15737 export function MessageSendEvent_broadcast_channel_update(msg: number): number {
15738 if(!isWasmInitialized) {
15739 throw new Error("initializeWasm() must be awaited first!");
15741 const nativeResponseValue = wasm.TS_MessageSendEvent_broadcast_channel_update(msg);
15742 return nativeResponseValue;
15744 // struct LDKMessageSendEvent MessageSendEvent_send_channel_update(struct LDKPublicKey node_id, struct LDKChannelUpdate msg);
15746 export function MessageSendEvent_send_channel_update(node_id: number, msg: number): number {
15747 if(!isWasmInitialized) {
15748 throw new Error("initializeWasm() must be awaited first!");
15750 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_update(node_id, msg);
15751 return nativeResponseValue;
15753 // struct LDKMessageSendEvent MessageSendEvent_handle_error(struct LDKPublicKey node_id, struct LDKErrorAction action);
15755 export function MessageSendEvent_handle_error(node_id: number, action: number): number {
15756 if(!isWasmInitialized) {
15757 throw new Error("initializeWasm() must be awaited first!");
15759 const nativeResponseValue = wasm.TS_MessageSendEvent_handle_error(node_id, action);
15760 return nativeResponseValue;
15762 // struct LDKMessageSendEvent MessageSendEvent_send_channel_range_query(struct LDKPublicKey node_id, struct LDKQueryChannelRange msg);
15764 export function MessageSendEvent_send_channel_range_query(node_id: number, msg: number): number {
15765 if(!isWasmInitialized) {
15766 throw new Error("initializeWasm() must be awaited first!");
15768 const nativeResponseValue = wasm.TS_MessageSendEvent_send_channel_range_query(node_id, msg);
15769 return nativeResponseValue;
15771 // struct LDKMessageSendEvent MessageSendEvent_send_short_ids_query(struct LDKPublicKey node_id, struct LDKQueryShortChannelIds msg);
15773 export function MessageSendEvent_send_short_ids_query(node_id: number, msg: number): number {
15774 if(!isWasmInitialized) {
15775 throw new Error("initializeWasm() must be awaited first!");
15777 const nativeResponseValue = wasm.TS_MessageSendEvent_send_short_ids_query(node_id, msg);
15778 return nativeResponseValue;
15780 // struct LDKMessageSendEvent MessageSendEvent_send_reply_channel_range(struct LDKPublicKey node_id, struct LDKReplyChannelRange msg);
15782 export function MessageSendEvent_send_reply_channel_range(node_id: number, msg: number): number {
15783 if(!isWasmInitialized) {
15784 throw new Error("initializeWasm() must be awaited first!");
15786 const nativeResponseValue = wasm.TS_MessageSendEvent_send_reply_channel_range(node_id, msg);
15787 return nativeResponseValue;
15789 // struct LDKMessageSendEvent MessageSendEvent_send_gossip_timestamp_filter(struct LDKPublicKey node_id, struct LDKGossipTimestampFilter msg);
15791 export function MessageSendEvent_send_gossip_timestamp_filter(node_id: number, msg: number): number {
15792 if(!isWasmInitialized) {
15793 throw new Error("initializeWasm() must be awaited first!");
15795 const nativeResponseValue = wasm.TS_MessageSendEvent_send_gossip_timestamp_filter(node_id, msg);
15796 return nativeResponseValue;
15798 // void MessageSendEventsProvider_free(struct LDKMessageSendEventsProvider this_ptr);
15800 export function MessageSendEventsProvider_free(this_ptr: number): void {
15801 if(!isWasmInitialized) {
15802 throw new Error("initializeWasm() must be awaited first!");
15804 const nativeResponseValue = wasm.TS_MessageSendEventsProvider_free(this_ptr);
15805 // debug statements here
15807 // void EventsProvider_free(struct LDKEventsProvider this_ptr);
15809 export function EventsProvider_free(this_ptr: number): void {
15810 if(!isWasmInitialized) {
15811 throw new Error("initializeWasm() must be awaited first!");
15813 const nativeResponseValue = wasm.TS_EventsProvider_free(this_ptr);
15814 // debug statements here
15816 // void EventHandler_free(struct LDKEventHandler this_ptr);
15818 export function EventHandler_free(this_ptr: number): void {
15819 if(!isWasmInitialized) {
15820 throw new Error("initializeWasm() must be awaited first!");
15822 const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
15823 // debug statements here
15825 // void APIError_free(struct LDKAPIError this_ptr);
15827 export function APIError_free(this_ptr: number): void {
15828 if(!isWasmInitialized) {
15829 throw new Error("initializeWasm() must be awaited first!");
15831 const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
15832 // debug statements here
15834 // uintptr_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
15836 export function APIError_clone_ptr(arg: number): number {
15837 if(!isWasmInitialized) {
15838 throw new Error("initializeWasm() must be awaited first!");
15840 const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
15841 return nativeResponseValue;
15843 // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
15845 export function APIError_clone(orig: number): number {
15846 if(!isWasmInitialized) {
15847 throw new Error("initializeWasm() must be awaited first!");
15849 const nativeResponseValue = wasm.TS_APIError_clone(orig);
15850 return nativeResponseValue;
15852 // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
15854 export function APIError_apimisuse_error(err: number): number {
15855 if(!isWasmInitialized) {
15856 throw new Error("initializeWasm() must be awaited first!");
15858 const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
15859 return nativeResponseValue;
15861 // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
15863 export function APIError_fee_rate_too_high(err: number, feerate: number): number {
15864 if(!isWasmInitialized) {
15865 throw new Error("initializeWasm() must be awaited first!");
15867 const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
15868 return nativeResponseValue;
15870 // struct LDKAPIError APIError_route_error(struct LDKStr err);
15872 export function APIError_route_error(err: number): number {
15873 if(!isWasmInitialized) {
15874 throw new Error("initializeWasm() must be awaited first!");
15876 const nativeResponseValue = wasm.TS_APIError_route_error(err);
15877 return nativeResponseValue;
15879 // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
15881 export function APIError_channel_unavailable(err: number): number {
15882 if(!isWasmInitialized) {
15883 throw new Error("initializeWasm() must be awaited first!");
15885 const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
15886 return nativeResponseValue;
15888 // struct LDKAPIError APIError_monitor_update_failed(void);
15890 export function APIError_monitor_update_failed(): number {
15891 if(!isWasmInitialized) {
15892 throw new Error("initializeWasm() must be awaited first!");
15894 const nativeResponseValue = wasm.TS_APIError_monitor_update_failed();
15895 return nativeResponseValue;
15897 // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
15899 export function APIError_incompatible_shutdown_script(script: number): number {
15900 if(!isWasmInitialized) {
15901 throw new Error("initializeWasm() must be awaited first!");
15903 const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
15904 return nativeResponseValue;
15906 // void BigSize_free(struct LDKBigSize this_obj);
15908 export function BigSize_free(this_obj: number): void {
15909 if(!isWasmInitialized) {
15910 throw new Error("initializeWasm() must be awaited first!");
15912 const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
15913 // debug statements here
15915 // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
15917 export function BigSize_get_a(this_ptr: number): bigint {
15918 if(!isWasmInitialized) {
15919 throw new Error("initializeWasm() must be awaited first!");
15921 const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
15922 return nativeResponseValue;
15924 // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
15926 export function BigSize_set_a(this_ptr: number, val: bigint): void {
15927 if(!isWasmInitialized) {
15928 throw new Error("initializeWasm() must be awaited first!");
15930 const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
15931 // debug statements here
15933 // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
15935 export function BigSize_new(a_arg: bigint): number {
15936 if(!isWasmInitialized) {
15937 throw new Error("initializeWasm() must be awaited first!");
15939 const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
15940 return nativeResponseValue;
15942 // struct LDKCResult_StringErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
15944 export function sign(msg: number, sk: number): number {
15945 if(!isWasmInitialized) {
15946 throw new Error("initializeWasm() must be awaited first!");
15948 const nativeResponseValue = wasm.TS_sign(msg, sk);
15949 return nativeResponseValue;
15951 // struct LDKCResult_PublicKeyErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
15953 export function recover_pk(msg: number, sig: number): number {
15954 if(!isWasmInitialized) {
15955 throw new Error("initializeWasm() must be awaited first!");
15957 const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
15958 return nativeResponseValue;
15960 // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
15962 export function verify(msg: number, sig: number, pk: number): boolean {
15963 if(!isWasmInitialized) {
15964 throw new Error("initializeWasm() must be awaited first!");
15966 const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
15967 return nativeResponseValue;
15969 // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_u5Z data_without_signature);
15971 export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
15972 if(!isWasmInitialized) {
15973 throw new Error("initializeWasm() must be awaited first!");
15975 const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
15976 return nativeResponseValue;
15978 // void Persister_free(struct LDKPersister this_ptr);
15980 export function Persister_free(this_ptr: number): void {
15981 if(!isWasmInitialized) {
15982 throw new Error("initializeWasm() must be awaited first!");
15984 const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
15985 // debug statements here
15987 // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
15989 export function Level_clone(orig: number): Level {
15990 if(!isWasmInitialized) {
15991 throw new Error("initializeWasm() must be awaited first!");
15993 const nativeResponseValue = wasm.TS_Level_clone(orig);
15994 return nativeResponseValue;
15996 // enum LDKLevel Level_gossip(void);
15998 export function Level_gossip(): Level {
15999 if(!isWasmInitialized) {
16000 throw new Error("initializeWasm() must be awaited first!");
16002 const nativeResponseValue = wasm.TS_Level_gossip();
16003 return nativeResponseValue;
16005 // enum LDKLevel Level_trace(void);
16007 export function Level_trace(): Level {
16008 if(!isWasmInitialized) {
16009 throw new Error("initializeWasm() must be awaited first!");
16011 const nativeResponseValue = wasm.TS_Level_trace();
16012 return nativeResponseValue;
16014 // enum LDKLevel Level_debug(void);
16016 export function Level_debug(): Level {
16017 if(!isWasmInitialized) {
16018 throw new Error("initializeWasm() must be awaited first!");
16020 const nativeResponseValue = wasm.TS_Level_debug();
16021 return nativeResponseValue;
16023 // enum LDKLevel Level_info(void);
16025 export function Level_info(): Level {
16026 if(!isWasmInitialized) {
16027 throw new Error("initializeWasm() must be awaited first!");
16029 const nativeResponseValue = wasm.TS_Level_info();
16030 return nativeResponseValue;
16032 // enum LDKLevel Level_warn(void);
16034 export function Level_warn(): Level {
16035 if(!isWasmInitialized) {
16036 throw new Error("initializeWasm() must be awaited first!");
16038 const nativeResponseValue = wasm.TS_Level_warn();
16039 return nativeResponseValue;
16041 // enum LDKLevel Level_error(void);
16043 export function Level_error(): Level {
16044 if(!isWasmInitialized) {
16045 throw new Error("initializeWasm() must be awaited first!");
16047 const nativeResponseValue = wasm.TS_Level_error();
16048 return nativeResponseValue;
16050 // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
16052 export function Level_eq(a: number, b: number): boolean {
16053 if(!isWasmInitialized) {
16054 throw new Error("initializeWasm() must be awaited first!");
16056 const nativeResponseValue = wasm.TS_Level_eq(a, b);
16057 return nativeResponseValue;
16059 // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
16061 export function Level_hash(o: number): bigint {
16062 if(!isWasmInitialized) {
16063 throw new Error("initializeWasm() must be awaited first!");
16065 const nativeResponseValue = wasm.TS_Level_hash(o);
16066 return nativeResponseValue;
16068 // MUST_USE_RES enum LDKLevel Level_max(void);
16070 export function Level_max(): Level {
16071 if(!isWasmInitialized) {
16072 throw new Error("initializeWasm() must be awaited first!");
16074 const nativeResponseValue = wasm.TS_Level_max();
16075 return nativeResponseValue;
16077 // void Record_free(struct LDKRecord this_obj);
16079 export function Record_free(this_obj: number): void {
16080 if(!isWasmInitialized) {
16081 throw new Error("initializeWasm() must be awaited first!");
16083 const nativeResponseValue = wasm.TS_Record_free(this_obj);
16084 // debug statements here
16086 // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
16088 export function Record_get_level(this_ptr: number): Level {
16089 if(!isWasmInitialized) {
16090 throw new Error("initializeWasm() must be awaited first!");
16092 const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
16093 return nativeResponseValue;
16095 // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);
16097 export function Record_set_level(this_ptr: number, val: Level): void {
16098 if(!isWasmInitialized) {
16099 throw new Error("initializeWasm() must be awaited first!");
16101 const nativeResponseValue = wasm.TS_Record_set_level(this_ptr, val);
16102 // debug statements here
16104 // struct LDKStr Record_get_args(const struct LDKRecord *NONNULL_PTR this_ptr);
16106 export function Record_get_args(this_ptr: number): number {
16107 if(!isWasmInitialized) {
16108 throw new Error("initializeWasm() must be awaited first!");
16110 const nativeResponseValue = wasm.TS_Record_get_args(this_ptr);
16111 return nativeResponseValue;
16113 // void Record_set_args(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16115 export function Record_set_args(this_ptr: number, val: number): void {
16116 if(!isWasmInitialized) {
16117 throw new Error("initializeWasm() must be awaited first!");
16119 const nativeResponseValue = wasm.TS_Record_set_args(this_ptr, val);
16120 // debug statements here
16122 // struct LDKStr Record_get_module_path(const struct LDKRecord *NONNULL_PTR this_ptr);
16124 export function Record_get_module_path(this_ptr: number): number {
16125 if(!isWasmInitialized) {
16126 throw new Error("initializeWasm() must be awaited first!");
16128 const nativeResponseValue = wasm.TS_Record_get_module_path(this_ptr);
16129 return nativeResponseValue;
16131 // void Record_set_module_path(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16133 export function Record_set_module_path(this_ptr: number, val: number): void {
16134 if(!isWasmInitialized) {
16135 throw new Error("initializeWasm() must be awaited first!");
16137 const nativeResponseValue = wasm.TS_Record_set_module_path(this_ptr, val);
16138 // debug statements here
16140 // struct LDKStr Record_get_file(const struct LDKRecord *NONNULL_PTR this_ptr);
16142 export function Record_get_file(this_ptr: number): number {
16143 if(!isWasmInitialized) {
16144 throw new Error("initializeWasm() must be awaited first!");
16146 const nativeResponseValue = wasm.TS_Record_get_file(this_ptr);
16147 return nativeResponseValue;
16149 // void Record_set_file(struct LDKRecord *NONNULL_PTR this_ptr, struct LDKStr val);
16151 export function Record_set_file(this_ptr: number, val: number): void {
16152 if(!isWasmInitialized) {
16153 throw new Error("initializeWasm() must be awaited first!");
16155 const nativeResponseValue = wasm.TS_Record_set_file(this_ptr, val);
16156 // debug statements here
16158 // uint32_t Record_get_line(const struct LDKRecord *NONNULL_PTR this_ptr);
16160 export function Record_get_line(this_ptr: number): number {
16161 if(!isWasmInitialized) {
16162 throw new Error("initializeWasm() must be awaited first!");
16164 const nativeResponseValue = wasm.TS_Record_get_line(this_ptr);
16165 return nativeResponseValue;
16167 // void Record_set_line(struct LDKRecord *NONNULL_PTR this_ptr, uint32_t val);
16169 export function Record_set_line(this_ptr: number, val: number): void {
16170 if(!isWasmInitialized) {
16171 throw new Error("initializeWasm() must be awaited first!");
16173 const nativeResponseValue = wasm.TS_Record_set_line(this_ptr, val);
16174 // debug statements here
16176 // uintptr_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg);
16178 export function Record_clone_ptr(arg: number): number {
16179 if(!isWasmInitialized) {
16180 throw new Error("initializeWasm() must be awaited first!");
16182 const nativeResponseValue = wasm.TS_Record_clone_ptr(arg);
16183 return nativeResponseValue;
16185 // struct LDKRecord Record_clone(const struct LDKRecord *NONNULL_PTR orig);
16187 export function Record_clone(orig: number): number {
16188 if(!isWasmInitialized) {
16189 throw new Error("initializeWasm() must be awaited first!");
16191 const nativeResponseValue = wasm.TS_Record_clone(orig);
16192 return nativeResponseValue;
16194 // void Logger_free(struct LDKLogger this_ptr);
16196 export function Logger_free(this_ptr: number): void {
16197 if(!isWasmInitialized) {
16198 throw new Error("initializeWasm() must be awaited first!");
16200 const nativeResponseValue = wasm.TS_Logger_free(this_ptr);
16201 // debug statements here
16203 // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
16205 export function ChannelHandshakeConfig_free(this_obj: number): void {
16206 if(!isWasmInitialized) {
16207 throw new Error("initializeWasm() must be awaited first!");
16209 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_free(this_obj);
16210 // debug statements here
16212 // uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16214 export function ChannelHandshakeConfig_get_minimum_depth(this_ptr: number): number {
16215 if(!isWasmInitialized) {
16216 throw new Error("initializeWasm() must be awaited first!");
16218 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_minimum_depth(this_ptr);
16219 return nativeResponseValue;
16221 // void ChannelHandshakeConfig_set_minimum_depth(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint32_t val);
16223 export function ChannelHandshakeConfig_set_minimum_depth(this_ptr: number, val: number): void {
16224 if(!isWasmInitialized) {
16225 throw new Error("initializeWasm() must be awaited first!");
16227 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_minimum_depth(this_ptr, val);
16228 // debug statements here
16230 // uint16_t ChannelHandshakeConfig_get_our_to_self_delay(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16232 export function ChannelHandshakeConfig_get_our_to_self_delay(this_ptr: number): number {
16233 if(!isWasmInitialized) {
16234 throw new Error("initializeWasm() must be awaited first!");
16236 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_to_self_delay(this_ptr);
16237 return nativeResponseValue;
16239 // void ChannelHandshakeConfig_set_our_to_self_delay(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint16_t val);
16241 export function ChannelHandshakeConfig_set_our_to_self_delay(this_ptr: number, val: number): void {
16242 if(!isWasmInitialized) {
16243 throw new Error("initializeWasm() must be awaited first!");
16245 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_to_self_delay(this_ptr, val);
16246 // debug statements here
16248 // uint64_t ChannelHandshakeConfig_get_our_htlc_minimum_msat(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16250 export function ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr: number): bigint {
16251 if(!isWasmInitialized) {
16252 throw new Error("initializeWasm() must be awaited first!");
16254 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(this_ptr);
16255 return nativeResponseValue;
16257 // void ChannelHandshakeConfig_set_our_htlc_minimum_msat(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint64_t val);
16259 export function ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16260 if(!isWasmInitialized) {
16261 throw new Error("initializeWasm() must be awaited first!");
16263 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(this_ptr, val);
16264 // debug statements here
16266 // uint8_t ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16268 export function ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: number): number {
16269 if(!isWasmInitialized) {
16270 throw new Error("initializeWasm() must be awaited first!");
16272 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr);
16273 return nativeResponseValue;
16275 // void ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, uint8_t val);
16277 export function ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr: number, val: number): void {
16278 if(!isWasmInitialized) {
16279 throw new Error("initializeWasm() must be awaited first!");
16281 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(this_ptr, val);
16282 // debug statements here
16284 // bool ChannelHandshakeConfig_get_negotiate_scid_privacy(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16286 export function ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr: number): boolean {
16287 if(!isWasmInitialized) {
16288 throw new Error("initializeWasm() must be awaited first!");
16290 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(this_ptr);
16291 return nativeResponseValue;
16293 // void ChannelHandshakeConfig_set_negotiate_scid_privacy(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16295 export function ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr: number, val: boolean): void {
16296 if(!isWasmInitialized) {
16297 throw new Error("initializeWasm() must be awaited first!");
16299 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(this_ptr, val);
16300 // debug statements here
16302 // bool ChannelHandshakeConfig_get_announced_channel(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16304 export function ChannelHandshakeConfig_get_announced_channel(this_ptr: number): boolean {
16305 if(!isWasmInitialized) {
16306 throw new Error("initializeWasm() must be awaited first!");
16308 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_announced_channel(this_ptr);
16309 return nativeResponseValue;
16311 // void ChannelHandshakeConfig_set_announced_channel(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16313 export function ChannelHandshakeConfig_set_announced_channel(this_ptr: number, val: boolean): void {
16314 if(!isWasmInitialized) {
16315 throw new Error("initializeWasm() must be awaited first!");
16317 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_announced_channel(this_ptr, val);
16318 // debug statements here
16320 // bool ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
16322 export function ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr: number): boolean {
16323 if(!isWasmInitialized) {
16324 throw new Error("initializeWasm() must be awaited first!");
16326 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(this_ptr);
16327 return nativeResponseValue;
16329 // void ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr, bool val);
16331 export function ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr: number, val: boolean): void {
16332 if(!isWasmInitialized) {
16333 throw new Error("initializeWasm() must be awaited first!");
16335 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
16336 // debug statements here
16338 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_new(uint32_t minimum_depth_arg, uint16_t our_to_self_delay_arg, uint64_t our_htlc_minimum_msat_arg, uint8_t max_inbound_htlc_value_in_flight_percent_of_channel_arg, bool negotiate_scid_privacy_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
16340 export function ChannelHandshakeConfig_new(minimum_depth_arg: number, our_to_self_delay_arg: number, our_htlc_minimum_msat_arg: bigint, max_inbound_htlc_value_in_flight_percent_of_channel_arg: number, negotiate_scid_privacy_arg: boolean, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean): number {
16341 if(!isWasmInitialized) {
16342 throw new Error("initializeWasm() must be awaited first!");
16344 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg, max_inbound_htlc_value_in_flight_percent_of_channel_arg, negotiate_scid_privacy_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
16345 return nativeResponseValue;
16347 // uintptr_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg);
16349 export function ChannelHandshakeConfig_clone_ptr(arg: number): number {
16350 if(!isWasmInitialized) {
16351 throw new Error("initializeWasm() must be awaited first!");
16353 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone_ptr(arg);
16354 return nativeResponseValue;
16356 // struct LDKChannelHandshakeConfig ChannelHandshakeConfig_clone(const struct LDKChannelHandshakeConfig *NONNULL_PTR orig);
16358 export function ChannelHandshakeConfig_clone(orig: number): number {
16359 if(!isWasmInitialized) {
16360 throw new Error("initializeWasm() must be awaited first!");
16362 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_clone(orig);
16363 return nativeResponseValue;
16365 // MUST_USE_RES struct LDKChannelHandshakeConfig ChannelHandshakeConfig_default(void);
16367 export function ChannelHandshakeConfig_default(): number {
16368 if(!isWasmInitialized) {
16369 throw new Error("initializeWasm() must be awaited first!");
16371 const nativeResponseValue = wasm.TS_ChannelHandshakeConfig_default();
16372 return nativeResponseValue;
16374 // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
16376 export function ChannelHandshakeLimits_free(this_obj: number): void {
16377 if(!isWasmInitialized) {
16378 throw new Error("initializeWasm() must be awaited first!");
16380 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_free(this_obj);
16381 // debug statements here
16383 // uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16385 export function ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr: number): bigint {
16386 if(!isWasmInitialized) {
16387 throw new Error("initializeWasm() must be awaited first!");
16389 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_funding_satoshis(this_ptr);
16390 return nativeResponseValue;
16392 // void ChannelHandshakeLimits_set_min_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16394 export function ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr: number, val: bigint): void {
16395 if(!isWasmInitialized) {
16396 throw new Error("initializeWasm() must be awaited first!");
16398 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_funding_satoshis(this_ptr, val);
16399 // debug statements here
16401 // uint64_t ChannelHandshakeLimits_get_max_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16403 export function ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr: number): bigint {
16404 if(!isWasmInitialized) {
16405 throw new Error("initializeWasm() must be awaited first!");
16407 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_funding_satoshis(this_ptr);
16408 return nativeResponseValue;
16410 // void ChannelHandshakeLimits_set_max_funding_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16412 export function ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr: number, val: bigint): void {
16413 if(!isWasmInitialized) {
16414 throw new Error("initializeWasm() must be awaited first!");
16416 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_funding_satoshis(this_ptr, val);
16417 // debug statements here
16419 // uint64_t ChannelHandshakeLimits_get_max_htlc_minimum_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16421 export function ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr: number): bigint {
16422 if(!isWasmInitialized) {
16423 throw new Error("initializeWasm() must be awaited first!");
16425 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(this_ptr);
16426 return nativeResponseValue;
16428 // void ChannelHandshakeLimits_set_max_htlc_minimum_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16430 export function ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr: number, val: bigint): void {
16431 if(!isWasmInitialized) {
16432 throw new Error("initializeWasm() must be awaited first!");
16434 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(this_ptr, val);
16435 // debug statements here
16437 // uint64_t ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16439 export function ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
16440 if(!isWasmInitialized) {
16441 throw new Error("initializeWasm() must be awaited first!");
16443 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(this_ptr);
16444 return nativeResponseValue;
16446 // void ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16448 export function ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
16449 if(!isWasmInitialized) {
16450 throw new Error("initializeWasm() must be awaited first!");
16452 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(this_ptr, val);
16453 // debug statements here
16455 // uint64_t ChannelHandshakeLimits_get_max_channel_reserve_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16457 export function ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr: number): bigint {
16458 if(!isWasmInitialized) {
16459 throw new Error("initializeWasm() must be awaited first!");
16461 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(this_ptr);
16462 return nativeResponseValue;
16464 // void ChannelHandshakeLimits_set_max_channel_reserve_satoshis(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint64_t val);
16466 export function ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
16467 if(!isWasmInitialized) {
16468 throw new Error("initializeWasm() must be awaited first!");
16470 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(this_ptr, val);
16471 // debug statements here
16473 // uint16_t ChannelHandshakeLimits_get_min_max_accepted_htlcs(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16475 export function ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr: number): number {
16476 if(!isWasmInitialized) {
16477 throw new Error("initializeWasm() must be awaited first!");
16479 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(this_ptr);
16480 return nativeResponseValue;
16482 // void ChannelHandshakeLimits_set_min_max_accepted_htlcs(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
16484 export function ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr: number, val: number): void {
16485 if(!isWasmInitialized) {
16486 throw new Error("initializeWasm() must be awaited first!");
16488 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(this_ptr, val);
16489 // debug statements here
16491 // uint32_t ChannelHandshakeLimits_get_max_minimum_depth(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16493 export function ChannelHandshakeLimits_get_max_minimum_depth(this_ptr: number): number {
16494 if(!isWasmInitialized) {
16495 throw new Error("initializeWasm() must be awaited first!");
16497 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_max_minimum_depth(this_ptr);
16498 return nativeResponseValue;
16500 // void ChannelHandshakeLimits_set_max_minimum_depth(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint32_t val);
16502 export function ChannelHandshakeLimits_set_max_minimum_depth(this_ptr: number, val: number): void {
16503 if(!isWasmInitialized) {
16504 throw new Error("initializeWasm() must be awaited first!");
16506 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_max_minimum_depth(this_ptr, val);
16507 // debug statements here
16509 // bool ChannelHandshakeLimits_get_trust_own_funding_0conf(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16511 export function ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr: number): boolean {
16512 if(!isWasmInitialized) {
16513 throw new Error("initializeWasm() must be awaited first!");
16515 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(this_ptr);
16516 return nativeResponseValue;
16518 // void ChannelHandshakeLimits_set_trust_own_funding_0conf(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
16520 export function ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr: number, val: boolean): void {
16521 if(!isWasmInitialized) {
16522 throw new Error("initializeWasm() must be awaited first!");
16524 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(this_ptr, val);
16525 // debug statements here
16527 // bool ChannelHandshakeLimits_get_force_announced_channel_preference(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16529 export function ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr: number): boolean {
16530 if(!isWasmInitialized) {
16531 throw new Error("initializeWasm() must be awaited first!");
16533 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_force_announced_channel_preference(this_ptr);
16534 return nativeResponseValue;
16536 // void ChannelHandshakeLimits_set_force_announced_channel_preference(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, bool val);
16538 export function ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr: number, val: boolean): void {
16539 if(!isWasmInitialized) {
16540 throw new Error("initializeWasm() must be awaited first!");
16542 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_force_announced_channel_preference(this_ptr, val);
16543 // debug statements here
16545 // uint16_t ChannelHandshakeLimits_get_their_to_self_delay(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
16547 export function ChannelHandshakeLimits_get_their_to_self_delay(this_ptr: number): number {
16548 if(!isWasmInitialized) {
16549 throw new Error("initializeWasm() must be awaited first!");
16551 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_get_their_to_self_delay(this_ptr);
16552 return nativeResponseValue;
16554 // void ChannelHandshakeLimits_set_their_to_self_delay(struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr, uint16_t val);
16556 export function ChannelHandshakeLimits_set_their_to_self_delay(this_ptr: number, val: number): void {
16557 if(!isWasmInitialized) {
16558 throw new Error("initializeWasm() must be awaited first!");
16560 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_set_their_to_self_delay(this_ptr, val);
16561 // debug statements here
16563 // 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);
16565 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 {
16566 if(!isWasmInitialized) {
16567 throw new Error("initializeWasm() must be awaited first!");
16569 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);
16570 return nativeResponseValue;
16572 // uintptr_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg);
16574 export function ChannelHandshakeLimits_clone_ptr(arg: number): number {
16575 if(!isWasmInitialized) {
16576 throw new Error("initializeWasm() must be awaited first!");
16578 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone_ptr(arg);
16579 return nativeResponseValue;
16581 // struct LDKChannelHandshakeLimits ChannelHandshakeLimits_clone(const struct LDKChannelHandshakeLimits *NONNULL_PTR orig);
16583 export function ChannelHandshakeLimits_clone(orig: number): number {
16584 if(!isWasmInitialized) {
16585 throw new Error("initializeWasm() must be awaited first!");
16587 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_clone(orig);
16588 return nativeResponseValue;
16590 // MUST_USE_RES struct LDKChannelHandshakeLimits ChannelHandshakeLimits_default(void);
16592 export function ChannelHandshakeLimits_default(): number {
16593 if(!isWasmInitialized) {
16594 throw new Error("initializeWasm() must be awaited first!");
16596 const nativeResponseValue = wasm.TS_ChannelHandshakeLimits_default();
16597 return nativeResponseValue;
16599 // void ChannelConfig_free(struct LDKChannelConfig this_obj);
16601 export function ChannelConfig_free(this_obj: number): void {
16602 if(!isWasmInitialized) {
16603 throw new Error("initializeWasm() must be awaited first!");
16605 const nativeResponseValue = wasm.TS_ChannelConfig_free(this_obj);
16606 // debug statements here
16608 // uint32_t ChannelConfig_get_forwarding_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16610 export function ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr: number): number {
16611 if(!isWasmInitialized) {
16612 throw new Error("initializeWasm() must be awaited first!");
16614 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_proportional_millionths(this_ptr);
16615 return nativeResponseValue;
16617 // void ChannelConfig_set_forwarding_fee_proportional_millionths(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
16619 export function ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr: number, val: number): void {
16620 if(!isWasmInitialized) {
16621 throw new Error("initializeWasm() must be awaited first!");
16623 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_proportional_millionths(this_ptr, val);
16624 // debug statements here
16626 // uint32_t ChannelConfig_get_forwarding_fee_base_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16628 export function ChannelConfig_get_forwarding_fee_base_msat(this_ptr: number): number {
16629 if(!isWasmInitialized) {
16630 throw new Error("initializeWasm() must be awaited first!");
16632 const nativeResponseValue = wasm.TS_ChannelConfig_get_forwarding_fee_base_msat(this_ptr);
16633 return nativeResponseValue;
16635 // void ChannelConfig_set_forwarding_fee_base_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint32_t val);
16637 export function ChannelConfig_set_forwarding_fee_base_msat(this_ptr: number, val: number): void {
16638 if(!isWasmInitialized) {
16639 throw new Error("initializeWasm() must be awaited first!");
16641 const nativeResponseValue = wasm.TS_ChannelConfig_set_forwarding_fee_base_msat(this_ptr, val);
16642 // debug statements here
16644 // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16646 export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
16647 if(!isWasmInitialized) {
16648 throw new Error("initializeWasm() must be awaited first!");
16650 const nativeResponseValue = wasm.TS_ChannelConfig_get_cltv_expiry_delta(this_ptr);
16651 return nativeResponseValue;
16653 // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
16655 export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
16656 if(!isWasmInitialized) {
16657 throw new Error("initializeWasm() must be awaited first!");
16659 const nativeResponseValue = wasm.TS_ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
16660 // debug statements here
16662 // uint64_t ChannelConfig_get_max_dust_htlc_exposure_msat(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16664 export function ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr: number): bigint {
16665 if(!isWasmInitialized) {
16666 throw new Error("initializeWasm() must be awaited first!");
16668 const nativeResponseValue = wasm.TS_ChannelConfig_get_max_dust_htlc_exposure_msat(this_ptr);
16669 return nativeResponseValue;
16671 // void ChannelConfig_set_max_dust_htlc_exposure_msat(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
16673 export function ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr: number, val: bigint): void {
16674 if(!isWasmInitialized) {
16675 throw new Error("initializeWasm() must be awaited first!");
16677 const nativeResponseValue = wasm.TS_ChannelConfig_set_max_dust_htlc_exposure_msat(this_ptr, val);
16678 // debug statements here
16680 // uint64_t ChannelConfig_get_force_close_avoidance_max_fee_satoshis(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
16682 export function ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr: number): bigint {
16683 if(!isWasmInitialized) {
16684 throw new Error("initializeWasm() must be awaited first!");
16686 const nativeResponseValue = wasm.TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(this_ptr);
16687 return nativeResponseValue;
16689 // void ChannelConfig_set_force_close_avoidance_max_fee_satoshis(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint64_t val);
16691 export function ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr: number, val: bigint): void {
16692 if(!isWasmInitialized) {
16693 throw new Error("initializeWasm() must be awaited first!");
16695 const nativeResponseValue = wasm.TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(this_ptr, val);
16696 // debug statements here
16698 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t forwarding_fee_proportional_millionths_arg, uint32_t forwarding_fee_base_msat_arg, uint16_t cltv_expiry_delta_arg, uint64_t max_dust_htlc_exposure_msat_arg, uint64_t force_close_avoidance_max_fee_satoshis_arg);
16700 export function ChannelConfig_new(forwarding_fee_proportional_millionths_arg: number, forwarding_fee_base_msat_arg: number, cltv_expiry_delta_arg: number, max_dust_htlc_exposure_msat_arg: bigint, force_close_avoidance_max_fee_satoshis_arg: bigint): number {
16701 if(!isWasmInitialized) {
16702 throw new Error("initializeWasm() must be awaited first!");
16704 const nativeResponseValue = wasm.TS_ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, max_dust_htlc_exposure_msat_arg, force_close_avoidance_max_fee_satoshis_arg);
16705 return nativeResponseValue;
16707 // uintptr_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg);
16709 export function ChannelConfig_clone_ptr(arg: number): number {
16710 if(!isWasmInitialized) {
16711 throw new Error("initializeWasm() must be awaited first!");
16713 const nativeResponseValue = wasm.TS_ChannelConfig_clone_ptr(arg);
16714 return nativeResponseValue;
16716 // struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
16718 export function ChannelConfig_clone(orig: number): number {
16719 if(!isWasmInitialized) {
16720 throw new Error("initializeWasm() must be awaited first!");
16722 const nativeResponseValue = wasm.TS_ChannelConfig_clone(orig);
16723 return nativeResponseValue;
16725 // MUST_USE_RES struct LDKChannelConfig ChannelConfig_default(void);
16727 export function ChannelConfig_default(): number {
16728 if(!isWasmInitialized) {
16729 throw new Error("initializeWasm() must be awaited first!");
16731 const nativeResponseValue = wasm.TS_ChannelConfig_default();
16732 return nativeResponseValue;
16734 // struct LDKCVec_u8Z ChannelConfig_write(const struct LDKChannelConfig *NONNULL_PTR obj);
16736 export function ChannelConfig_write(obj: number): number {
16737 if(!isWasmInitialized) {
16738 throw new Error("initializeWasm() must be awaited first!");
16740 const nativeResponseValue = wasm.TS_ChannelConfig_write(obj);
16741 return nativeResponseValue;
16743 // struct LDKCResult_ChannelConfigDecodeErrorZ ChannelConfig_read(struct LDKu8slice ser);
16745 export function ChannelConfig_read(ser: number): number {
16746 if(!isWasmInitialized) {
16747 throw new Error("initializeWasm() must be awaited first!");
16749 const nativeResponseValue = wasm.TS_ChannelConfig_read(ser);
16750 return nativeResponseValue;
16752 // void UserConfig_free(struct LDKUserConfig this_obj);
16754 export function UserConfig_free(this_obj: number): void {
16755 if(!isWasmInitialized) {
16756 throw new Error("initializeWasm() must be awaited first!");
16758 const nativeResponseValue = wasm.TS_UserConfig_free(this_obj);
16759 // debug statements here
16761 // struct LDKChannelHandshakeConfig UserConfig_get_channel_handshake_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16763 export function UserConfig_get_channel_handshake_config(this_ptr: number): number {
16764 if(!isWasmInitialized) {
16765 throw new Error("initializeWasm() must be awaited first!");
16767 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_config(this_ptr);
16768 return nativeResponseValue;
16770 // void UserConfig_set_channel_handshake_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeConfig val);
16772 export function UserConfig_set_channel_handshake_config(this_ptr: number, val: number): void {
16773 if(!isWasmInitialized) {
16774 throw new Error("initializeWasm() must be awaited first!");
16776 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_config(this_ptr, val);
16777 // debug statements here
16779 // struct LDKChannelHandshakeLimits UserConfig_get_channel_handshake_limits(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16781 export function UserConfig_get_channel_handshake_limits(this_ptr: number): number {
16782 if(!isWasmInitialized) {
16783 throw new Error("initializeWasm() must be awaited first!");
16785 const nativeResponseValue = wasm.TS_UserConfig_get_channel_handshake_limits(this_ptr);
16786 return nativeResponseValue;
16788 // void UserConfig_set_channel_handshake_limits(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelHandshakeLimits val);
16790 export function UserConfig_set_channel_handshake_limits(this_ptr: number, val: number): void {
16791 if(!isWasmInitialized) {
16792 throw new Error("initializeWasm() must be awaited first!");
16794 const nativeResponseValue = wasm.TS_UserConfig_set_channel_handshake_limits(this_ptr, val);
16795 // debug statements here
16797 // struct LDKChannelConfig UserConfig_get_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16799 export function UserConfig_get_channel_config(this_ptr: number): number {
16800 if(!isWasmInitialized) {
16801 throw new Error("initializeWasm() must be awaited first!");
16803 const nativeResponseValue = wasm.TS_UserConfig_get_channel_config(this_ptr);
16804 return nativeResponseValue;
16806 // void UserConfig_set_channel_config(struct LDKUserConfig *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
16808 export function UserConfig_set_channel_config(this_ptr: number, val: number): void {
16809 if(!isWasmInitialized) {
16810 throw new Error("initializeWasm() must be awaited first!");
16812 const nativeResponseValue = wasm.TS_UserConfig_set_channel_config(this_ptr, val);
16813 // debug statements here
16815 // bool UserConfig_get_accept_forwards_to_priv_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16817 export function UserConfig_get_accept_forwards_to_priv_channels(this_ptr: number): boolean {
16818 if(!isWasmInitialized) {
16819 throw new Error("initializeWasm() must be awaited first!");
16821 const nativeResponseValue = wasm.TS_UserConfig_get_accept_forwards_to_priv_channels(this_ptr);
16822 return nativeResponseValue;
16824 // void UserConfig_set_accept_forwards_to_priv_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16826 export function UserConfig_set_accept_forwards_to_priv_channels(this_ptr: number, val: boolean): void {
16827 if(!isWasmInitialized) {
16828 throw new Error("initializeWasm() must be awaited first!");
16830 const nativeResponseValue = wasm.TS_UserConfig_set_accept_forwards_to_priv_channels(this_ptr, val);
16831 // debug statements here
16833 // bool UserConfig_get_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16835 export function UserConfig_get_accept_inbound_channels(this_ptr: number): boolean {
16836 if(!isWasmInitialized) {
16837 throw new Error("initializeWasm() must be awaited first!");
16839 const nativeResponseValue = wasm.TS_UserConfig_get_accept_inbound_channels(this_ptr);
16840 return nativeResponseValue;
16842 // void UserConfig_set_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16844 export function UserConfig_set_accept_inbound_channels(this_ptr: number, val: boolean): void {
16845 if(!isWasmInitialized) {
16846 throw new Error("initializeWasm() must be awaited first!");
16848 const nativeResponseValue = wasm.TS_UserConfig_set_accept_inbound_channels(this_ptr, val);
16849 // debug statements here
16851 // bool UserConfig_get_manually_accept_inbound_channels(const struct LDKUserConfig *NONNULL_PTR this_ptr);
16853 export function UserConfig_get_manually_accept_inbound_channels(this_ptr: number): boolean {
16854 if(!isWasmInitialized) {
16855 throw new Error("initializeWasm() must be awaited first!");
16857 const nativeResponseValue = wasm.TS_UserConfig_get_manually_accept_inbound_channels(this_ptr);
16858 return nativeResponseValue;
16860 // void UserConfig_set_manually_accept_inbound_channels(struct LDKUserConfig *NONNULL_PTR this_ptr, bool val);
16862 export function UserConfig_set_manually_accept_inbound_channels(this_ptr: number, val: boolean): void {
16863 if(!isWasmInitialized) {
16864 throw new Error("initializeWasm() must be awaited first!");
16866 const nativeResponseValue = wasm.TS_UserConfig_set_manually_accept_inbound_channels(this_ptr, val);
16867 // debug statements here
16869 // MUST_USE_RES struct LDKUserConfig UserConfig_new(struct LDKChannelHandshakeConfig channel_handshake_config_arg, struct LDKChannelHandshakeLimits channel_handshake_limits_arg, struct LDKChannelConfig channel_config_arg, bool accept_forwards_to_priv_channels_arg, bool accept_inbound_channels_arg, bool manually_accept_inbound_channels_arg);
16871 export function UserConfig_new(channel_handshake_config_arg: number, channel_handshake_limits_arg: number, channel_config_arg: number, accept_forwards_to_priv_channels_arg: boolean, accept_inbound_channels_arg: boolean, manually_accept_inbound_channels_arg: boolean): number {
16872 if(!isWasmInitialized) {
16873 throw new Error("initializeWasm() must be awaited first!");
16875 const nativeResponseValue = wasm.TS_UserConfig_new(channel_handshake_config_arg, channel_handshake_limits_arg, channel_config_arg, accept_forwards_to_priv_channels_arg, accept_inbound_channels_arg, manually_accept_inbound_channels_arg);
16876 return nativeResponseValue;
16878 // uintptr_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg);
16880 export function UserConfig_clone_ptr(arg: number): number {
16881 if(!isWasmInitialized) {
16882 throw new Error("initializeWasm() must be awaited first!");
16884 const nativeResponseValue = wasm.TS_UserConfig_clone_ptr(arg);
16885 return nativeResponseValue;
16887 // struct LDKUserConfig UserConfig_clone(const struct LDKUserConfig *NONNULL_PTR orig);
16889 export function UserConfig_clone(orig: number): number {
16890 if(!isWasmInitialized) {
16891 throw new Error("initializeWasm() must be awaited first!");
16893 const nativeResponseValue = wasm.TS_UserConfig_clone(orig);
16894 return nativeResponseValue;
16896 // MUST_USE_RES struct LDKUserConfig UserConfig_default(void);
16898 export function UserConfig_default(): number {
16899 if(!isWasmInitialized) {
16900 throw new Error("initializeWasm() must be awaited first!");
16902 const nativeResponseValue = wasm.TS_UserConfig_default();
16903 return nativeResponseValue;
16905 // void BestBlock_free(struct LDKBestBlock this_obj);
16907 export function BestBlock_free(this_obj: number): void {
16908 if(!isWasmInitialized) {
16909 throw new Error("initializeWasm() must be awaited first!");
16911 const nativeResponseValue = wasm.TS_BestBlock_free(this_obj);
16912 // debug statements here
16914 // uintptr_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg);
16916 export function BestBlock_clone_ptr(arg: number): number {
16917 if(!isWasmInitialized) {
16918 throw new Error("initializeWasm() must be awaited first!");
16920 const nativeResponseValue = wasm.TS_BestBlock_clone_ptr(arg);
16921 return nativeResponseValue;
16923 // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
16925 export function BestBlock_clone(orig: number): number {
16926 if(!isWasmInitialized) {
16927 throw new Error("initializeWasm() must be awaited first!");
16929 const nativeResponseValue = wasm.TS_BestBlock_clone(orig);
16930 return nativeResponseValue;
16932 // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
16934 export function BestBlock_from_genesis(network: Network): number {
16935 if(!isWasmInitialized) {
16936 throw new Error("initializeWasm() must be awaited first!");
16938 const nativeResponseValue = wasm.TS_BestBlock_from_genesis(network);
16939 return nativeResponseValue;
16941 // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
16943 export function BestBlock_new(block_hash: number, height: number): number {
16944 if(!isWasmInitialized) {
16945 throw new Error("initializeWasm() must be awaited first!");
16947 const nativeResponseValue = wasm.TS_BestBlock_new(block_hash, height);
16948 return nativeResponseValue;
16950 // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
16952 export function BestBlock_block_hash(this_arg: number): number {
16953 if(!isWasmInitialized) {
16954 throw new Error("initializeWasm() must be awaited first!");
16956 const nativeResponseValue = wasm.TS_BestBlock_block_hash(this_arg);
16957 return nativeResponseValue;
16959 // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
16961 export function BestBlock_height(this_arg: number): number {
16962 if(!isWasmInitialized) {
16963 throw new Error("initializeWasm() must be awaited first!");
16965 const nativeResponseValue = wasm.TS_BestBlock_height(this_arg);
16966 return nativeResponseValue;
16968 // enum LDKAccessError AccessError_clone(const enum LDKAccessError *NONNULL_PTR orig);
16970 export function AccessError_clone(orig: number): AccessError {
16971 if(!isWasmInitialized) {
16972 throw new Error("initializeWasm() must be awaited first!");
16974 const nativeResponseValue = wasm.TS_AccessError_clone(orig);
16975 return nativeResponseValue;
16977 // enum LDKAccessError AccessError_unknown_chain(void);
16979 export function AccessError_unknown_chain(): AccessError {
16980 if(!isWasmInitialized) {
16981 throw new Error("initializeWasm() must be awaited first!");
16983 const nativeResponseValue = wasm.TS_AccessError_unknown_chain();
16984 return nativeResponseValue;
16986 // enum LDKAccessError AccessError_unknown_tx(void);
16988 export function AccessError_unknown_tx(): AccessError {
16989 if(!isWasmInitialized) {
16990 throw new Error("initializeWasm() must be awaited first!");
16992 const nativeResponseValue = wasm.TS_AccessError_unknown_tx();
16993 return nativeResponseValue;
16995 // void Access_free(struct LDKAccess this_ptr);
16997 export function Access_free(this_ptr: number): void {
16998 if(!isWasmInitialized) {
16999 throw new Error("initializeWasm() must be awaited first!");
17001 const nativeResponseValue = wasm.TS_Access_free(this_ptr);
17002 // debug statements here
17004 // void Listen_free(struct LDKListen this_ptr);
17006 export function Listen_free(this_ptr: number): void {
17007 if(!isWasmInitialized) {
17008 throw new Error("initializeWasm() must be awaited first!");
17010 const nativeResponseValue = wasm.TS_Listen_free(this_ptr);
17011 // debug statements here
17013 // void Confirm_free(struct LDKConfirm this_ptr);
17015 export function Confirm_free(this_ptr: number): void {
17016 if(!isWasmInitialized) {
17017 throw new Error("initializeWasm() must be awaited first!");
17019 const nativeResponseValue = wasm.TS_Confirm_free(this_ptr);
17020 // debug statements here
17022 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_clone(const enum LDKChannelMonitorUpdateErr *NONNULL_PTR orig);
17024 export function ChannelMonitorUpdateErr_clone(orig: number): ChannelMonitorUpdateErr {
17025 if(!isWasmInitialized) {
17026 throw new Error("initializeWasm() must be awaited first!");
17028 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_clone(orig);
17029 return nativeResponseValue;
17031 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_temporary_failure(void);
17033 export function ChannelMonitorUpdateErr_temporary_failure(): ChannelMonitorUpdateErr {
17034 if(!isWasmInitialized) {
17035 throw new Error("initializeWasm() must be awaited first!");
17037 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_temporary_failure();
17038 return nativeResponseValue;
17040 // enum LDKChannelMonitorUpdateErr ChannelMonitorUpdateErr_permanent_failure(void);
17042 export function ChannelMonitorUpdateErr_permanent_failure(): ChannelMonitorUpdateErr {
17043 if(!isWasmInitialized) {
17044 throw new Error("initializeWasm() must be awaited first!");
17046 const nativeResponseValue = wasm.TS_ChannelMonitorUpdateErr_permanent_failure();
17047 return nativeResponseValue;
17049 // void Watch_free(struct LDKWatch this_ptr);
17051 export function Watch_free(this_ptr: number): void {
17052 if(!isWasmInitialized) {
17053 throw new Error("initializeWasm() must be awaited first!");
17055 const nativeResponseValue = wasm.TS_Watch_free(this_ptr);
17056 // debug statements here
17058 // void Filter_free(struct LDKFilter this_ptr);
17060 export function Filter_free(this_ptr: number): void {
17061 if(!isWasmInitialized) {
17062 throw new Error("initializeWasm() must be awaited first!");
17064 const nativeResponseValue = wasm.TS_Filter_free(this_ptr);
17065 // debug statements here
17067 // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
17069 export function WatchedOutput_free(this_obj: number): void {
17070 if(!isWasmInitialized) {
17071 throw new Error("initializeWasm() must be awaited first!");
17073 const nativeResponseValue = wasm.TS_WatchedOutput_free(this_obj);
17074 // debug statements here
17076 // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17078 export function WatchedOutput_get_block_hash(this_ptr: number): number {
17079 if(!isWasmInitialized) {
17080 throw new Error("initializeWasm() must be awaited first!");
17082 const nativeResponseValue = wasm.TS_WatchedOutput_get_block_hash(this_ptr);
17083 return nativeResponseValue;
17085 // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17087 export function WatchedOutput_set_block_hash(this_ptr: number, val: number): void {
17088 if(!isWasmInitialized) {
17089 throw new Error("initializeWasm() must be awaited first!");
17091 const nativeResponseValue = wasm.TS_WatchedOutput_set_block_hash(this_ptr, val);
17092 // debug statements here
17094 // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17096 export function WatchedOutput_get_outpoint(this_ptr: number): number {
17097 if(!isWasmInitialized) {
17098 throw new Error("initializeWasm() must be awaited first!");
17100 const nativeResponseValue = wasm.TS_WatchedOutput_get_outpoint(this_ptr);
17101 return nativeResponseValue;
17103 // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17105 export function WatchedOutput_set_outpoint(this_ptr: number, val: number): void {
17106 if(!isWasmInitialized) {
17107 throw new Error("initializeWasm() must be awaited first!");
17109 const nativeResponseValue = wasm.TS_WatchedOutput_set_outpoint(this_ptr, val);
17110 // debug statements here
17112 // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
17114 export function WatchedOutput_get_script_pubkey(this_ptr: number): number {
17115 if(!isWasmInitialized) {
17116 throw new Error("initializeWasm() must be awaited first!");
17118 const nativeResponseValue = wasm.TS_WatchedOutput_get_script_pubkey(this_ptr);
17119 return nativeResponseValue;
17121 // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
17123 export function WatchedOutput_set_script_pubkey(this_ptr: number, val: number): void {
17124 if(!isWasmInitialized) {
17125 throw new Error("initializeWasm() must be awaited first!");
17127 const nativeResponseValue = wasm.TS_WatchedOutput_set_script_pubkey(this_ptr, val);
17128 // debug statements here
17130 // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
17132 export function WatchedOutput_new(block_hash_arg: number, outpoint_arg: number, script_pubkey_arg: number): number {
17133 if(!isWasmInitialized) {
17134 throw new Error("initializeWasm() must be awaited first!");
17136 const nativeResponseValue = wasm.TS_WatchedOutput_new(block_hash_arg, outpoint_arg, script_pubkey_arg);
17137 return nativeResponseValue;
17139 // uintptr_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg);
17141 export function WatchedOutput_clone_ptr(arg: number): number {
17142 if(!isWasmInitialized) {
17143 throw new Error("initializeWasm() must be awaited first!");
17145 const nativeResponseValue = wasm.TS_WatchedOutput_clone_ptr(arg);
17146 return nativeResponseValue;
17148 // struct LDKWatchedOutput WatchedOutput_clone(const struct LDKWatchedOutput *NONNULL_PTR orig);
17150 export function WatchedOutput_clone(orig: number): number {
17151 if(!isWasmInitialized) {
17152 throw new Error("initializeWasm() must be awaited first!");
17154 const nativeResponseValue = wasm.TS_WatchedOutput_clone(orig);
17155 return nativeResponseValue;
17157 // uint64_t WatchedOutput_hash(const struct LDKWatchedOutput *NONNULL_PTR o);
17159 export function WatchedOutput_hash(o: number): bigint {
17160 if(!isWasmInitialized) {
17161 throw new Error("initializeWasm() must be awaited first!");
17163 const nativeResponseValue = wasm.TS_WatchedOutput_hash(o);
17164 return nativeResponseValue;
17166 // void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
17168 export function BroadcasterInterface_free(this_ptr: number): void {
17169 if(!isWasmInitialized) {
17170 throw new Error("initializeWasm() must be awaited first!");
17172 const nativeResponseValue = wasm.TS_BroadcasterInterface_free(this_ptr);
17173 // debug statements here
17175 // enum LDKConfirmationTarget ConfirmationTarget_clone(const enum LDKConfirmationTarget *NONNULL_PTR orig);
17177 export function ConfirmationTarget_clone(orig: number): ConfirmationTarget {
17178 if(!isWasmInitialized) {
17179 throw new Error("initializeWasm() must be awaited first!");
17181 const nativeResponseValue = wasm.TS_ConfirmationTarget_clone(orig);
17182 return nativeResponseValue;
17184 // enum LDKConfirmationTarget ConfirmationTarget_background(void);
17186 export function ConfirmationTarget_background(): ConfirmationTarget {
17187 if(!isWasmInitialized) {
17188 throw new Error("initializeWasm() must be awaited first!");
17190 const nativeResponseValue = wasm.TS_ConfirmationTarget_background();
17191 return nativeResponseValue;
17193 // enum LDKConfirmationTarget ConfirmationTarget_normal(void);
17195 export function ConfirmationTarget_normal(): ConfirmationTarget {
17196 if(!isWasmInitialized) {
17197 throw new Error("initializeWasm() must be awaited first!");
17199 const nativeResponseValue = wasm.TS_ConfirmationTarget_normal();
17200 return nativeResponseValue;
17202 // enum LDKConfirmationTarget ConfirmationTarget_high_priority(void);
17204 export function ConfirmationTarget_high_priority(): ConfirmationTarget {
17205 if(!isWasmInitialized) {
17206 throw new Error("initializeWasm() must be awaited first!");
17208 const nativeResponseValue = wasm.TS_ConfirmationTarget_high_priority();
17209 return nativeResponseValue;
17211 // bool ConfirmationTarget_eq(const enum LDKConfirmationTarget *NONNULL_PTR a, const enum LDKConfirmationTarget *NONNULL_PTR b);
17213 export function ConfirmationTarget_eq(a: number, b: number): boolean {
17214 if(!isWasmInitialized) {
17215 throw new Error("initializeWasm() must be awaited first!");
17217 const nativeResponseValue = wasm.TS_ConfirmationTarget_eq(a, b);
17218 return nativeResponseValue;
17220 // void FeeEstimator_free(struct LDKFeeEstimator this_ptr);
17222 export function FeeEstimator_free(this_ptr: number): void {
17223 if(!isWasmInitialized) {
17224 throw new Error("initializeWasm() must be awaited first!");
17226 const nativeResponseValue = wasm.TS_FeeEstimator_free(this_ptr);
17227 // debug statements here
17229 // void MonitorUpdateId_free(struct LDKMonitorUpdateId this_obj);
17231 export function MonitorUpdateId_free(this_obj: number): void {
17232 if(!isWasmInitialized) {
17233 throw new Error("initializeWasm() must be awaited first!");
17235 const nativeResponseValue = wasm.TS_MonitorUpdateId_free(this_obj);
17236 // debug statements here
17238 // uintptr_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg);
17240 export function MonitorUpdateId_clone_ptr(arg: number): number {
17241 if(!isWasmInitialized) {
17242 throw new Error("initializeWasm() must be awaited first!");
17244 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone_ptr(arg);
17245 return nativeResponseValue;
17247 // struct LDKMonitorUpdateId MonitorUpdateId_clone(const struct LDKMonitorUpdateId *NONNULL_PTR orig);
17249 export function MonitorUpdateId_clone(orig: number): number {
17250 if(!isWasmInitialized) {
17251 throw new Error("initializeWasm() must be awaited first!");
17253 const nativeResponseValue = wasm.TS_MonitorUpdateId_clone(orig);
17254 return nativeResponseValue;
17256 // uint64_t MonitorUpdateId_hash(const struct LDKMonitorUpdateId *NONNULL_PTR o);
17258 export function MonitorUpdateId_hash(o: number): bigint {
17259 if(!isWasmInitialized) {
17260 throw new Error("initializeWasm() must be awaited first!");
17262 const nativeResponseValue = wasm.TS_MonitorUpdateId_hash(o);
17263 return nativeResponseValue;
17265 // bool MonitorUpdateId_eq(const struct LDKMonitorUpdateId *NONNULL_PTR a, const struct LDKMonitorUpdateId *NONNULL_PTR b);
17267 export function MonitorUpdateId_eq(a: number, b: number): boolean {
17268 if(!isWasmInitialized) {
17269 throw new Error("initializeWasm() must be awaited first!");
17271 const nativeResponseValue = wasm.TS_MonitorUpdateId_eq(a, b);
17272 return nativeResponseValue;
17274 // void Persist_free(struct LDKPersist this_ptr);
17276 export function Persist_free(this_ptr: number): void {
17277 if(!isWasmInitialized) {
17278 throw new Error("initializeWasm() must be awaited first!");
17280 const nativeResponseValue = wasm.TS_Persist_free(this_ptr);
17281 // debug statements here
17283 // void LockedChannelMonitor_free(struct LDKLockedChannelMonitor this_obj);
17285 export function LockedChannelMonitor_free(this_obj: number): void {
17286 if(!isWasmInitialized) {
17287 throw new Error("initializeWasm() must be awaited first!");
17289 const nativeResponseValue = wasm.TS_LockedChannelMonitor_free(this_obj);
17290 // debug statements here
17292 // void ChainMonitor_free(struct LDKChainMonitor this_obj);
17294 export function ChainMonitor_free(this_obj: number): void {
17295 if(!isWasmInitialized) {
17296 throw new Error("initializeWasm() must be awaited first!");
17298 const nativeResponseValue = wasm.TS_ChainMonitor_free(this_obj);
17299 // debug statements here
17301 // MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKCOption_FilterZ chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
17303 export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
17304 if(!isWasmInitialized) {
17305 throw new Error("initializeWasm() must be awaited first!");
17307 const nativeResponseValue = wasm.TS_ChainMonitor_new(chain_source, broadcaster, logger, feeest, persister);
17308 return nativeResponseValue;
17310 // MUST_USE_RES struct LDKCVec_BalanceZ ChainMonitor_get_claimable_balances(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKCVec_ChannelDetailsZ ignored_channels);
17312 export function ChainMonitor_get_claimable_balances(this_arg: number, ignored_channels: number): number {
17313 if(!isWasmInitialized) {
17314 throw new Error("initializeWasm() must be awaited first!");
17316 const nativeResponseValue = wasm.TS_ChainMonitor_get_claimable_balances(this_arg, ignored_channels);
17317 return nativeResponseValue;
17319 // MUST_USE_RES struct LDKCResult_LockedChannelMonitorNoneZ ChainMonitor_get_monitor(const struct LDKChainMonitor *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo);
17321 export function ChainMonitor_get_monitor(this_arg: number, funding_txo: number): number {
17322 if(!isWasmInitialized) {
17323 throw new Error("initializeWasm() must be awaited first!");
17325 const nativeResponseValue = wasm.TS_ChainMonitor_get_monitor(this_arg, funding_txo);
17326 return nativeResponseValue;
17328 // MUST_USE_RES struct LDKCVec_OutPointZ ChainMonitor_list_monitors(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17330 export function ChainMonitor_list_monitors(this_arg: number): number {
17331 if(!isWasmInitialized) {
17332 throw new Error("initializeWasm() must be awaited first!");
17334 const nativeResponseValue = wasm.TS_ChainMonitor_list_monitors(this_arg);
17335 return nativeResponseValue;
17337 // 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);
17339 export function ChainMonitor_channel_monitor_updated(this_arg: number, funding_txo: number, completed_update_id: number): number {
17340 if(!isWasmInitialized) {
17341 throw new Error("initializeWasm() must be awaited first!");
17343 const nativeResponseValue = wasm.TS_ChainMonitor_channel_monitor_updated(this_arg, funding_txo, completed_update_id);
17344 return nativeResponseValue;
17346 // struct LDKListen ChainMonitor_as_Listen(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17348 export function ChainMonitor_as_Listen(this_arg: number): number {
17349 if(!isWasmInitialized) {
17350 throw new Error("initializeWasm() must be awaited first!");
17352 const nativeResponseValue = wasm.TS_ChainMonitor_as_Listen(this_arg);
17353 return nativeResponseValue;
17355 // struct LDKConfirm ChainMonitor_as_Confirm(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17357 export function ChainMonitor_as_Confirm(this_arg: number): number {
17358 if(!isWasmInitialized) {
17359 throw new Error("initializeWasm() must be awaited first!");
17361 const nativeResponseValue = wasm.TS_ChainMonitor_as_Confirm(this_arg);
17362 return nativeResponseValue;
17364 // struct LDKWatch ChainMonitor_as_Watch(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17366 export function ChainMonitor_as_Watch(this_arg: number): number {
17367 if(!isWasmInitialized) {
17368 throw new Error("initializeWasm() must be awaited first!");
17370 const nativeResponseValue = wasm.TS_ChainMonitor_as_Watch(this_arg);
17371 return nativeResponseValue;
17373 // struct LDKEventsProvider ChainMonitor_as_EventsProvider(const struct LDKChainMonitor *NONNULL_PTR this_arg);
17375 export function ChainMonitor_as_EventsProvider(this_arg: number): number {
17376 if(!isWasmInitialized) {
17377 throw new Error("initializeWasm() must be awaited first!");
17379 const nativeResponseValue = wasm.TS_ChainMonitor_as_EventsProvider(this_arg);
17380 return nativeResponseValue;
17382 // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
17384 export function ChannelMonitorUpdate_free(this_obj: number): void {
17385 if(!isWasmInitialized) {
17386 throw new Error("initializeWasm() must be awaited first!");
17388 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_free(this_obj);
17389 // debug statements here
17391 // uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
17393 export function ChannelMonitorUpdate_get_update_id(this_ptr: number): bigint {
17394 if(!isWasmInitialized) {
17395 throw new Error("initializeWasm() must be awaited first!");
17397 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_get_update_id(this_ptr);
17398 return nativeResponseValue;
17400 // void ChannelMonitorUpdate_set_update_id(struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr, uint64_t val);
17402 export function ChannelMonitorUpdate_set_update_id(this_ptr: number, val: bigint): void {
17403 if(!isWasmInitialized) {
17404 throw new Error("initializeWasm() must be awaited first!");
17406 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_set_update_id(this_ptr, val);
17407 // debug statements here
17409 // uintptr_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg);
17411 export function ChannelMonitorUpdate_clone_ptr(arg: number): number {
17412 if(!isWasmInitialized) {
17413 throw new Error("initializeWasm() must be awaited first!");
17415 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone_ptr(arg);
17416 return nativeResponseValue;
17418 // struct LDKChannelMonitorUpdate ChannelMonitorUpdate_clone(const struct LDKChannelMonitorUpdate *NONNULL_PTR orig);
17420 export function ChannelMonitorUpdate_clone(orig: number): number {
17421 if(!isWasmInitialized) {
17422 throw new Error("initializeWasm() must be awaited first!");
17424 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_clone(orig);
17425 return nativeResponseValue;
17427 // struct LDKCVec_u8Z ChannelMonitorUpdate_write(const struct LDKChannelMonitorUpdate *NONNULL_PTR obj);
17429 export function ChannelMonitorUpdate_write(obj: number): number {
17430 if(!isWasmInitialized) {
17431 throw new Error("initializeWasm() must be awaited first!");
17433 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_write(obj);
17434 return nativeResponseValue;
17436 // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ ChannelMonitorUpdate_read(struct LDKu8slice ser);
17438 export function ChannelMonitorUpdate_read(ser: number): number {
17439 if(!isWasmInitialized) {
17440 throw new Error("initializeWasm() must be awaited first!");
17442 const nativeResponseValue = wasm.TS_ChannelMonitorUpdate_read(ser);
17443 return nativeResponseValue;
17445 // void MonitorEvent_free(struct LDKMonitorEvent this_ptr);
17447 export function MonitorEvent_free(this_ptr: number): void {
17448 if(!isWasmInitialized) {
17449 throw new Error("initializeWasm() must be awaited first!");
17451 const nativeResponseValue = wasm.TS_MonitorEvent_free(this_ptr);
17452 // debug statements here
17454 // uintptr_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg);
17456 export function MonitorEvent_clone_ptr(arg: number): number {
17457 if(!isWasmInitialized) {
17458 throw new Error("initializeWasm() must be awaited first!");
17460 const nativeResponseValue = wasm.TS_MonitorEvent_clone_ptr(arg);
17461 return nativeResponseValue;
17463 // struct LDKMonitorEvent MonitorEvent_clone(const struct LDKMonitorEvent *NONNULL_PTR orig);
17465 export function MonitorEvent_clone(orig: number): number {
17466 if(!isWasmInitialized) {
17467 throw new Error("initializeWasm() must be awaited first!");
17469 const nativeResponseValue = wasm.TS_MonitorEvent_clone(orig);
17470 return nativeResponseValue;
17472 // struct LDKMonitorEvent MonitorEvent_htlcevent(struct LDKHTLCUpdate a);
17474 export function MonitorEvent_htlcevent(a: number): number {
17475 if(!isWasmInitialized) {
17476 throw new Error("initializeWasm() must be awaited first!");
17478 const nativeResponseValue = wasm.TS_MonitorEvent_htlcevent(a);
17479 return nativeResponseValue;
17481 // struct LDKMonitorEvent MonitorEvent_commitment_tx_confirmed(struct LDKOutPoint a);
17483 export function MonitorEvent_commitment_tx_confirmed(a: number): number {
17484 if(!isWasmInitialized) {
17485 throw new Error("initializeWasm() must be awaited first!");
17487 const nativeResponseValue = wasm.TS_MonitorEvent_commitment_tx_confirmed(a);
17488 return nativeResponseValue;
17490 // struct LDKMonitorEvent MonitorEvent_update_completed(struct LDKOutPoint funding_txo, uint64_t monitor_update_id);
17492 export function MonitorEvent_update_completed(funding_txo: number, monitor_update_id: bigint): number {
17493 if(!isWasmInitialized) {
17494 throw new Error("initializeWasm() must be awaited first!");
17496 const nativeResponseValue = wasm.TS_MonitorEvent_update_completed(funding_txo, monitor_update_id);
17497 return nativeResponseValue;
17499 // struct LDKMonitorEvent MonitorEvent_update_failed(struct LDKOutPoint a);
17501 export function MonitorEvent_update_failed(a: number): number {
17502 if(!isWasmInitialized) {
17503 throw new Error("initializeWasm() must be awaited first!");
17505 const nativeResponseValue = wasm.TS_MonitorEvent_update_failed(a);
17506 return nativeResponseValue;
17508 // struct LDKCVec_u8Z MonitorEvent_write(const struct LDKMonitorEvent *NONNULL_PTR obj);
17510 export function MonitorEvent_write(obj: number): number {
17511 if(!isWasmInitialized) {
17512 throw new Error("initializeWasm() must be awaited first!");
17514 const nativeResponseValue = wasm.TS_MonitorEvent_write(obj);
17515 return nativeResponseValue;
17517 // struct LDKCResult_COption_MonitorEventZDecodeErrorZ MonitorEvent_read(struct LDKu8slice ser);
17519 export function MonitorEvent_read(ser: number): number {
17520 if(!isWasmInitialized) {
17521 throw new Error("initializeWasm() must be awaited first!");
17523 const nativeResponseValue = wasm.TS_MonitorEvent_read(ser);
17524 return nativeResponseValue;
17526 // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
17528 export function HTLCUpdate_free(this_obj: number): void {
17529 if(!isWasmInitialized) {
17530 throw new Error("initializeWasm() must be awaited first!");
17532 const nativeResponseValue = wasm.TS_HTLCUpdate_free(this_obj);
17533 // debug statements here
17535 // uintptr_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg);
17537 export function HTLCUpdate_clone_ptr(arg: number): number {
17538 if(!isWasmInitialized) {
17539 throw new Error("initializeWasm() must be awaited first!");
17541 const nativeResponseValue = wasm.TS_HTLCUpdate_clone_ptr(arg);
17542 return nativeResponseValue;
17544 // struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
17546 export function HTLCUpdate_clone(orig: number): number {
17547 if(!isWasmInitialized) {
17548 throw new Error("initializeWasm() must be awaited first!");
17550 const nativeResponseValue = wasm.TS_HTLCUpdate_clone(orig);
17551 return nativeResponseValue;
17553 // struct LDKCVec_u8Z HTLCUpdate_write(const struct LDKHTLCUpdate *NONNULL_PTR obj);
17555 export function HTLCUpdate_write(obj: number): number {
17556 if(!isWasmInitialized) {
17557 throw new Error("initializeWasm() must be awaited first!");
17559 const nativeResponseValue = wasm.TS_HTLCUpdate_write(obj);
17560 return nativeResponseValue;
17562 // struct LDKCResult_HTLCUpdateDecodeErrorZ HTLCUpdate_read(struct LDKu8slice ser);
17564 export function HTLCUpdate_read(ser: number): number {
17565 if(!isWasmInitialized) {
17566 throw new Error("initializeWasm() must be awaited first!");
17568 const nativeResponseValue = wasm.TS_HTLCUpdate_read(ser);
17569 return nativeResponseValue;
17571 // void Balance_free(struct LDKBalance this_ptr);
17573 export function Balance_free(this_ptr: number): void {
17574 if(!isWasmInitialized) {
17575 throw new Error("initializeWasm() must be awaited first!");
17577 const nativeResponseValue = wasm.TS_Balance_free(this_ptr);
17578 // debug statements here
17580 // uintptr_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg);
17582 export function Balance_clone_ptr(arg: number): number {
17583 if(!isWasmInitialized) {
17584 throw new Error("initializeWasm() must be awaited first!");
17586 const nativeResponseValue = wasm.TS_Balance_clone_ptr(arg);
17587 return nativeResponseValue;
17589 // struct LDKBalance Balance_clone(const struct LDKBalance *NONNULL_PTR orig);
17591 export function Balance_clone(orig: number): number {
17592 if(!isWasmInitialized) {
17593 throw new Error("initializeWasm() must be awaited first!");
17595 const nativeResponseValue = wasm.TS_Balance_clone(orig);
17596 return nativeResponseValue;
17598 // struct LDKBalance Balance_claimable_on_channel_close(uint64_t claimable_amount_satoshis);
17600 export function Balance_claimable_on_channel_close(claimable_amount_satoshis: bigint): number {
17601 if(!isWasmInitialized) {
17602 throw new Error("initializeWasm() must be awaited first!");
17604 const nativeResponseValue = wasm.TS_Balance_claimable_on_channel_close(claimable_amount_satoshis);
17605 return nativeResponseValue;
17607 // struct LDKBalance Balance_claimable_awaiting_confirmations(uint64_t claimable_amount_satoshis, uint32_t confirmation_height);
17609 export function Balance_claimable_awaiting_confirmations(claimable_amount_satoshis: bigint, confirmation_height: number): number {
17610 if(!isWasmInitialized) {
17611 throw new Error("initializeWasm() must be awaited first!");
17613 const nativeResponseValue = wasm.TS_Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
17614 return nativeResponseValue;
17616 // struct LDKBalance Balance_contentious_claimable(uint64_t claimable_amount_satoshis, uint32_t timeout_height);
17618 export function Balance_contentious_claimable(claimable_amount_satoshis: bigint, timeout_height: number): number {
17619 if(!isWasmInitialized) {
17620 throw new Error("initializeWasm() must be awaited first!");
17622 const nativeResponseValue = wasm.TS_Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
17623 return nativeResponseValue;
17625 // struct LDKBalance Balance_maybe_claimable_htlcawaiting_timeout(uint64_t claimable_amount_satoshis, uint32_t claimable_height);
17627 export function Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis: bigint, claimable_height: number): number {
17628 if(!isWasmInitialized) {
17629 throw new Error("initializeWasm() must be awaited first!");
17631 const nativeResponseValue = wasm.TS_Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
17632 return nativeResponseValue;
17634 // bool Balance_eq(const struct LDKBalance *NONNULL_PTR a, const struct LDKBalance *NONNULL_PTR b);
17636 export function Balance_eq(a: number, b: number): boolean {
17637 if(!isWasmInitialized) {
17638 throw new Error("initializeWasm() must be awaited first!");
17640 const nativeResponseValue = wasm.TS_Balance_eq(a, b);
17641 return nativeResponseValue;
17643 // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
17645 export function ChannelMonitor_free(this_obj: number): void {
17646 if(!isWasmInitialized) {
17647 throw new Error("initializeWasm() must be awaited first!");
17649 const nativeResponseValue = wasm.TS_ChannelMonitor_free(this_obj);
17650 // debug statements here
17652 // uintptr_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg);
17654 export function ChannelMonitor_clone_ptr(arg: number): number {
17655 if(!isWasmInitialized) {
17656 throw new Error("initializeWasm() must be awaited first!");
17658 const nativeResponseValue = wasm.TS_ChannelMonitor_clone_ptr(arg);
17659 return nativeResponseValue;
17661 // struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
17663 export function ChannelMonitor_clone(orig: number): number {
17664 if(!isWasmInitialized) {
17665 throw new Error("initializeWasm() must be awaited first!");
17667 const nativeResponseValue = wasm.TS_ChannelMonitor_clone(orig);
17668 return nativeResponseValue;
17670 // struct LDKCVec_u8Z ChannelMonitor_write(const struct LDKChannelMonitor *NONNULL_PTR obj);
17672 export function ChannelMonitor_write(obj: number): number {
17673 if(!isWasmInitialized) {
17674 throw new Error("initializeWasm() must be awaited first!");
17676 const nativeResponseValue = wasm.TS_ChannelMonitor_write(obj);
17677 return nativeResponseValue;
17679 // 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);
17681 export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number {
17682 if(!isWasmInitialized) {
17683 throw new Error("initializeWasm() must be awaited first!");
17685 const nativeResponseValue = wasm.TS_ChannelMonitor_update_monitor(this_arg, updates, broadcaster, fee_estimator, logger);
17686 return nativeResponseValue;
17688 // MUST_USE_RES uint64_t ChannelMonitor_get_latest_update_id(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17690 export function ChannelMonitor_get_latest_update_id(this_arg: number): bigint {
17691 if(!isWasmInitialized) {
17692 throw new Error("initializeWasm() must be awaited first!");
17694 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_update_id(this_arg);
17695 return nativeResponseValue;
17697 // MUST_USE_RES struct LDKC2Tuple_OutPointScriptZ ChannelMonitor_get_funding_txo(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17699 export function ChannelMonitor_get_funding_txo(this_arg: number): number {
17700 if(!isWasmInitialized) {
17701 throw new Error("initializeWasm() must be awaited first!");
17703 const nativeResponseValue = wasm.TS_ChannelMonitor_get_funding_txo(this_arg);
17704 return nativeResponseValue;
17706 // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17708 export function ChannelMonitor_get_outputs_to_watch(this_arg: number): number {
17709 if(!isWasmInitialized) {
17710 throw new Error("initializeWasm() must be awaited first!");
17712 const nativeResponseValue = wasm.TS_ChannelMonitor_get_outputs_to_watch(this_arg);
17713 return nativeResponseValue;
17715 // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
17717 export function ChannelMonitor_load_outputs_to_watch(this_arg: number, filter: number): void {
17718 if(!isWasmInitialized) {
17719 throw new Error("initializeWasm() must be awaited first!");
17721 const nativeResponseValue = wasm.TS_ChannelMonitor_load_outputs_to_watch(this_arg, filter);
17722 // debug statements here
17724 // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17726 export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number {
17727 if(!isWasmInitialized) {
17728 throw new Error("initializeWasm() must be awaited first!");
17730 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_monitor_events(this_arg);
17731 return nativeResponseValue;
17733 // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17735 export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number {
17736 if(!isWasmInitialized) {
17737 throw new Error("initializeWasm() must be awaited first!");
17739 const nativeResponseValue = wasm.TS_ChannelMonitor_get_and_clear_pending_events(this_arg);
17740 return nativeResponseValue;
17742 // 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);
17744 export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): number {
17745 if(!isWasmInitialized) {
17746 throw new Error("initializeWasm() must be awaited first!");
17748 const nativeResponseValue = wasm.TS_ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger);
17749 return nativeResponseValue;
17751 // 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);
17753 export function ChannelMonitor_block_connected(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17754 if(!isWasmInitialized) {
17755 throw new Error("initializeWasm() must be awaited first!");
17757 const nativeResponseValue = wasm.TS_ChannelMonitor_block_connected(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
17758 return nativeResponseValue;
17760 // 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);
17762 export function ChannelMonitor_block_disconnected(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): void {
17763 if(!isWasmInitialized) {
17764 throw new Error("initializeWasm() must be awaited first!");
17766 const nativeResponseValue = wasm.TS_ChannelMonitor_block_disconnected(this_arg, header, height, broadcaster, fee_estimator, logger);
17767 // debug statements here
17769 // 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);
17771 export function ChannelMonitor_transactions_confirmed(this_arg: number, header: number, txdata: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17772 if(!isWasmInitialized) {
17773 throw new Error("initializeWasm() must be awaited first!");
17775 const nativeResponseValue = wasm.TS_ChannelMonitor_transactions_confirmed(this_arg, header, txdata, height, broadcaster, fee_estimator, logger);
17776 return nativeResponseValue;
17778 // 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);
17780 export function ChannelMonitor_transaction_unconfirmed(this_arg: number, txid: number, broadcaster: number, fee_estimator: number, logger: number): void {
17781 if(!isWasmInitialized) {
17782 throw new Error("initializeWasm() must be awaited first!");
17784 const nativeResponseValue = wasm.TS_ChannelMonitor_transaction_unconfirmed(this_arg, txid, broadcaster, fee_estimator, logger);
17785 // debug statements here
17787 // 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);
17789 export function ChannelMonitor_best_block_updated(this_arg: number, header: number, height: number, broadcaster: number, fee_estimator: number, logger: number): number {
17790 if(!isWasmInitialized) {
17791 throw new Error("initializeWasm() must be awaited first!");
17793 const nativeResponseValue = wasm.TS_ChannelMonitor_best_block_updated(this_arg, header, height, broadcaster, fee_estimator, logger);
17794 return nativeResponseValue;
17796 // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17798 export function ChannelMonitor_get_relevant_txids(this_arg: number): number {
17799 if(!isWasmInitialized) {
17800 throw new Error("initializeWasm() must be awaited first!");
17802 const nativeResponseValue = wasm.TS_ChannelMonitor_get_relevant_txids(this_arg);
17803 return nativeResponseValue;
17805 // MUST_USE_RES struct LDKBestBlock ChannelMonitor_current_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17807 export function ChannelMonitor_current_best_block(this_arg: number): number {
17808 if(!isWasmInitialized) {
17809 throw new Error("initializeWasm() must be awaited first!");
17811 const nativeResponseValue = wasm.TS_ChannelMonitor_current_best_block(this_arg);
17812 return nativeResponseValue;
17814 // MUST_USE_RES struct LDKCVec_BalanceZ ChannelMonitor_get_claimable_balances(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
17816 export function ChannelMonitor_get_claimable_balances(this_arg: number): number {
17817 if(!isWasmInitialized) {
17818 throw new Error("initializeWasm() must be awaited first!");
17820 const nativeResponseValue = wasm.TS_ChannelMonitor_get_claimable_balances(this_arg);
17821 return nativeResponseValue;
17823 // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ C2Tuple_BlockHashChannelMonitorZ_read(struct LDKu8slice ser, const struct LDKKeysInterface *NONNULL_PTR arg);
17825 export function C2Tuple_BlockHashChannelMonitorZ_read(ser: number, arg: number): number {
17826 if(!isWasmInitialized) {
17827 throw new Error("initializeWasm() must be awaited first!");
17829 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelMonitorZ_read(ser, arg);
17830 return nativeResponseValue;
17832 // void OutPoint_free(struct LDKOutPoint this_obj);
17834 export function OutPoint_free(this_obj: number): void {
17835 if(!isWasmInitialized) {
17836 throw new Error("initializeWasm() must be awaited first!");
17838 const nativeResponseValue = wasm.TS_OutPoint_free(this_obj);
17839 // debug statements here
17841 // const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
17843 export function OutPoint_get_txid(this_ptr: number): number {
17844 if(!isWasmInitialized) {
17845 throw new Error("initializeWasm() must be awaited first!");
17847 const nativeResponseValue = wasm.TS_OutPoint_get_txid(this_ptr);
17848 return nativeResponseValue;
17850 // void OutPoint_set_txid(struct LDKOutPoint *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
17852 export function OutPoint_set_txid(this_ptr: number, val: number): void {
17853 if(!isWasmInitialized) {
17854 throw new Error("initializeWasm() must be awaited first!");
17856 const nativeResponseValue = wasm.TS_OutPoint_set_txid(this_ptr, val);
17857 // debug statements here
17859 // uint16_t OutPoint_get_index(const struct LDKOutPoint *NONNULL_PTR this_ptr);
17861 export function OutPoint_get_index(this_ptr: number): number {
17862 if(!isWasmInitialized) {
17863 throw new Error("initializeWasm() must be awaited first!");
17865 const nativeResponseValue = wasm.TS_OutPoint_get_index(this_ptr);
17866 return nativeResponseValue;
17868 // void OutPoint_set_index(struct LDKOutPoint *NONNULL_PTR this_ptr, uint16_t val);
17870 export function OutPoint_set_index(this_ptr: number, val: number): void {
17871 if(!isWasmInitialized) {
17872 throw new Error("initializeWasm() must be awaited first!");
17874 const nativeResponseValue = wasm.TS_OutPoint_set_index(this_ptr, val);
17875 // debug statements here
17877 // MUST_USE_RES struct LDKOutPoint OutPoint_new(struct LDKThirtyTwoBytes txid_arg, uint16_t index_arg);
17879 export function OutPoint_new(txid_arg: number, index_arg: number): number {
17880 if(!isWasmInitialized) {
17881 throw new Error("initializeWasm() must be awaited first!");
17883 const nativeResponseValue = wasm.TS_OutPoint_new(txid_arg, index_arg);
17884 return nativeResponseValue;
17886 // uintptr_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg);
17888 export function OutPoint_clone_ptr(arg: number): number {
17889 if(!isWasmInitialized) {
17890 throw new Error("initializeWasm() must be awaited first!");
17892 const nativeResponseValue = wasm.TS_OutPoint_clone_ptr(arg);
17893 return nativeResponseValue;
17895 // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig);
17897 export function OutPoint_clone(orig: number): number {
17898 if(!isWasmInitialized) {
17899 throw new Error("initializeWasm() must be awaited first!");
17901 const nativeResponseValue = wasm.TS_OutPoint_clone(orig);
17902 return nativeResponseValue;
17904 // bool OutPoint_eq(const struct LDKOutPoint *NONNULL_PTR a, const struct LDKOutPoint *NONNULL_PTR b);
17906 export function OutPoint_eq(a: number, b: number): boolean {
17907 if(!isWasmInitialized) {
17908 throw new Error("initializeWasm() must be awaited first!");
17910 const nativeResponseValue = wasm.TS_OutPoint_eq(a, b);
17911 return nativeResponseValue;
17913 // uint64_t OutPoint_hash(const struct LDKOutPoint *NONNULL_PTR o);
17915 export function OutPoint_hash(o: number): bigint {
17916 if(!isWasmInitialized) {
17917 throw new Error("initializeWasm() must be awaited first!");
17919 const nativeResponseValue = wasm.TS_OutPoint_hash(o);
17920 return nativeResponseValue;
17922 // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg);
17924 export function OutPoint_to_channel_id(this_arg: number): number {
17925 if(!isWasmInitialized) {
17926 throw new Error("initializeWasm() must be awaited first!");
17928 const nativeResponseValue = wasm.TS_OutPoint_to_channel_id(this_arg);
17929 return nativeResponseValue;
17931 // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj);
17933 export function OutPoint_write(obj: number): number {
17934 if(!isWasmInitialized) {
17935 throw new Error("initializeWasm() must be awaited first!");
17937 const nativeResponseValue = wasm.TS_OutPoint_write(obj);
17938 return nativeResponseValue;
17940 // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser);
17942 export function OutPoint_read(ser: number): number {
17943 if(!isWasmInitialized) {
17944 throw new Error("initializeWasm() must be awaited first!");
17946 const nativeResponseValue = wasm.TS_OutPoint_read(ser);
17947 return nativeResponseValue;
17949 // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
17951 export function DelayedPaymentOutputDescriptor_free(this_obj: number): void {
17952 if(!isWasmInitialized) {
17953 throw new Error("initializeWasm() must be awaited first!");
17955 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_free(this_obj);
17956 // debug statements here
17958 // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17960 export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
17961 if(!isWasmInitialized) {
17962 throw new Error("initializeWasm() must be awaited first!");
17964 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_outpoint(this_ptr);
17965 return nativeResponseValue;
17967 // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
17969 export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
17970 if(!isWasmInitialized) {
17971 throw new Error("initializeWasm() must be awaited first!");
17973 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val);
17974 // debug statements here
17976 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17978 export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): number {
17979 if(!isWasmInitialized) {
17980 throw new Error("initializeWasm() must be awaited first!");
17982 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr);
17983 return nativeResponseValue;
17985 // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
17987 export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: number, val: number): void {
17988 if(!isWasmInitialized) {
17989 throw new Error("initializeWasm() must be awaited first!");
17991 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, val);
17992 // debug statements here
17994 // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
17996 export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number {
17997 if(!isWasmInitialized) {
17998 throw new Error("initializeWasm() must be awaited first!");
18000 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr);
18001 return nativeResponseValue;
18003 // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val);
18005 export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: number, val: number): void {
18006 if(!isWasmInitialized) {
18007 throw new Error("initializeWasm() must be awaited first!");
18009 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val);
18010 // debug statements here
18012 // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
18014 export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
18015 if(!isWasmInitialized) {
18016 throw new Error("initializeWasm() must be awaited first!");
18018 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_output(this_ptr, val);
18019 // debug statements here
18021 // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18023 export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): number {
18024 if(!isWasmInitialized) {
18025 throw new Error("initializeWasm() must be awaited first!");
18027 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr);
18028 return nativeResponseValue;
18030 // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18032 export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: number, val: number): void {
18033 if(!isWasmInitialized) {
18034 throw new Error("initializeWasm() must be awaited first!");
18036 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, val);
18037 // debug statements here
18039 // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
18041 export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
18042 if(!isWasmInitialized) {
18043 throw new Error("initializeWasm() must be awaited first!");
18045 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
18046 return nativeResponseValue;
18048 // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18050 export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
18051 if(!isWasmInitialized) {
18052 throw new Error("initializeWasm() must be awaited first!");
18054 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
18055 // debug statements here
18057 // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18059 export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
18060 if(!isWasmInitialized) {
18061 throw new Error("initializeWasm() must be awaited first!");
18063 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
18064 return nativeResponseValue;
18066 // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
18068 export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18069 if(!isWasmInitialized) {
18070 throw new Error("initializeWasm() must be awaited first!");
18072 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
18073 // debug statements here
18075 // 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);
18077 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 {
18078 if(!isWasmInitialized) {
18079 throw new Error("initializeWasm() must be awaited first!");
18081 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);
18082 return nativeResponseValue;
18084 // uintptr_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg);
18086 export function DelayedPaymentOutputDescriptor_clone_ptr(arg: number): number {
18087 if(!isWasmInitialized) {
18088 throw new Error("initializeWasm() must be awaited first!");
18090 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone_ptr(arg);
18091 return nativeResponseValue;
18093 // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig);
18095 export function DelayedPaymentOutputDescriptor_clone(orig: number): number {
18096 if(!isWasmInitialized) {
18097 throw new Error("initializeWasm() must be awaited first!");
18099 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_clone(orig);
18100 return nativeResponseValue;
18102 // struct LDKCVec_u8Z DelayedPaymentOutputDescriptor_write(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR obj);
18104 export function DelayedPaymentOutputDescriptor_write(obj: number): number {
18105 if(!isWasmInitialized) {
18106 throw new Error("initializeWasm() must be awaited first!");
18108 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_write(obj);
18109 return nativeResponseValue;
18111 // struct LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ DelayedPaymentOutputDescriptor_read(struct LDKu8slice ser);
18113 export function DelayedPaymentOutputDescriptor_read(ser: number): number {
18114 if(!isWasmInitialized) {
18115 throw new Error("initializeWasm() must be awaited first!");
18117 const nativeResponseValue = wasm.TS_DelayedPaymentOutputDescriptor_read(ser);
18118 return nativeResponseValue;
18120 // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
18122 export function StaticPaymentOutputDescriptor_free(this_obj: number): void {
18123 if(!isWasmInitialized) {
18124 throw new Error("initializeWasm() must be awaited first!");
18126 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_free(this_obj);
18127 // debug statements here
18129 // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18131 export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number {
18132 if(!isWasmInitialized) {
18133 throw new Error("initializeWasm() must be awaited first!");
18135 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_outpoint(this_ptr);
18136 return nativeResponseValue;
18138 // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
18140 export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void {
18141 if(!isWasmInitialized) {
18142 throw new Error("initializeWasm() must be awaited first!");
18144 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val);
18145 // debug statements here
18147 // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val);
18149 export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void {
18150 if(!isWasmInitialized) {
18151 throw new Error("initializeWasm() must be awaited first!");
18153 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_output(this_ptr, val);
18154 // debug statements here
18156 // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32];
18158 export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): number {
18159 if(!isWasmInitialized) {
18160 throw new Error("initializeWasm() must be awaited first!");
18162 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr);
18163 return nativeResponseValue;
18165 // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18167 export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: number): void {
18168 if(!isWasmInitialized) {
18169 throw new Error("initializeWasm() must be awaited first!");
18171 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, val);
18172 // debug statements here
18174 // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
18176 export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): bigint {
18177 if(!isWasmInitialized) {
18178 throw new Error("initializeWasm() must be awaited first!");
18180 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr);
18181 return nativeResponseValue;
18183 // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val);
18185 export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
18186 if(!isWasmInitialized) {
18187 throw new Error("initializeWasm() must be awaited first!");
18189 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val);
18190 // debug statements here
18192 // 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);
18194 export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: number, channel_value_satoshis_arg: bigint): number {
18195 if(!isWasmInitialized) {
18196 throw new Error("initializeWasm() must be awaited first!");
18198 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, channel_keys_id_arg, channel_value_satoshis_arg);
18199 return nativeResponseValue;
18201 // uintptr_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg);
18203 export function StaticPaymentOutputDescriptor_clone_ptr(arg: number): number {
18204 if(!isWasmInitialized) {
18205 throw new Error("initializeWasm() must be awaited first!");
18207 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone_ptr(arg);
18208 return nativeResponseValue;
18210 // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig);
18212 export function StaticPaymentOutputDescriptor_clone(orig: number): number {
18213 if(!isWasmInitialized) {
18214 throw new Error("initializeWasm() must be awaited first!");
18216 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_clone(orig);
18217 return nativeResponseValue;
18219 // struct LDKCVec_u8Z StaticPaymentOutputDescriptor_write(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR obj);
18221 export function StaticPaymentOutputDescriptor_write(obj: number): number {
18222 if(!isWasmInitialized) {
18223 throw new Error("initializeWasm() must be awaited first!");
18225 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_write(obj);
18226 return nativeResponseValue;
18228 // struct LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ StaticPaymentOutputDescriptor_read(struct LDKu8slice ser);
18230 export function StaticPaymentOutputDescriptor_read(ser: number): number {
18231 if(!isWasmInitialized) {
18232 throw new Error("initializeWasm() must be awaited first!");
18234 const nativeResponseValue = wasm.TS_StaticPaymentOutputDescriptor_read(ser);
18235 return nativeResponseValue;
18237 // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr);
18239 export function SpendableOutputDescriptor_free(this_ptr: number): void {
18240 if(!isWasmInitialized) {
18241 throw new Error("initializeWasm() must be awaited first!");
18243 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_free(this_ptr);
18244 // debug statements here
18246 // uintptr_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg);
18248 export function SpendableOutputDescriptor_clone_ptr(arg: number): number {
18249 if(!isWasmInitialized) {
18250 throw new Error("initializeWasm() must be awaited first!");
18252 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone_ptr(arg);
18253 return nativeResponseValue;
18255 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_clone(const struct LDKSpendableOutputDescriptor *NONNULL_PTR orig);
18257 export function SpendableOutputDescriptor_clone(orig: number): number {
18258 if(!isWasmInitialized) {
18259 throw new Error("initializeWasm() must be awaited first!");
18261 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_clone(orig);
18262 return nativeResponseValue;
18264 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_output(struct LDKOutPoint outpoint, struct LDKTxOut output);
18266 export function SpendableOutputDescriptor_static_output(outpoint: number, output: number): number {
18267 if(!isWasmInitialized) {
18268 throw new Error("initializeWasm() must be awaited first!");
18270 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_output(outpoint, output);
18271 return nativeResponseValue;
18273 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_delayed_payment_output(struct LDKDelayedPaymentOutputDescriptor a);
18275 export function SpendableOutputDescriptor_delayed_payment_output(a: number): number {
18276 if(!isWasmInitialized) {
18277 throw new Error("initializeWasm() must be awaited first!");
18279 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_delayed_payment_output(a);
18280 return nativeResponseValue;
18282 // struct LDKSpendableOutputDescriptor SpendableOutputDescriptor_static_payment_output(struct LDKStaticPaymentOutputDescriptor a);
18284 export function SpendableOutputDescriptor_static_payment_output(a: number): number {
18285 if(!isWasmInitialized) {
18286 throw new Error("initializeWasm() must be awaited first!");
18288 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_static_payment_output(a);
18289 return nativeResponseValue;
18291 // struct LDKCVec_u8Z SpendableOutputDescriptor_write(const struct LDKSpendableOutputDescriptor *NONNULL_PTR obj);
18293 export function SpendableOutputDescriptor_write(obj: number): number {
18294 if(!isWasmInitialized) {
18295 throw new Error("initializeWasm() must be awaited first!");
18297 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_write(obj);
18298 return nativeResponseValue;
18300 // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ SpendableOutputDescriptor_read(struct LDKu8slice ser);
18302 export function SpendableOutputDescriptor_read(ser: number): number {
18303 if(!isWasmInitialized) {
18304 throw new Error("initializeWasm() must be awaited first!");
18306 const nativeResponseValue = wasm.TS_SpendableOutputDescriptor_read(ser);
18307 return nativeResponseValue;
18309 // void BaseSign_free(struct LDKBaseSign this_ptr);
18311 export function BaseSign_free(this_ptr: number): void {
18312 if(!isWasmInitialized) {
18313 throw new Error("initializeWasm() must be awaited first!");
18315 const nativeResponseValue = wasm.TS_BaseSign_free(this_ptr);
18316 // debug statements here
18318 // uintptr_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg);
18320 export function Sign_clone_ptr(arg: number): number {
18321 if(!isWasmInitialized) {
18322 throw new Error("initializeWasm() must be awaited first!");
18324 const nativeResponseValue = wasm.TS_Sign_clone_ptr(arg);
18325 return nativeResponseValue;
18327 // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
18329 export function Sign_clone(orig: number): number {
18330 if(!isWasmInitialized) {
18331 throw new Error("initializeWasm() must be awaited first!");
18333 const nativeResponseValue = wasm.TS_Sign_clone(orig);
18334 return nativeResponseValue;
18336 // void Sign_free(struct LDKSign this_ptr);
18338 export function Sign_free(this_ptr: number): void {
18339 if(!isWasmInitialized) {
18340 throw new Error("initializeWasm() must be awaited first!");
18342 const nativeResponseValue = wasm.TS_Sign_free(this_ptr);
18343 // debug statements here
18345 // enum LDKRecipient Recipient_clone(const enum LDKRecipient *NONNULL_PTR orig);
18347 export function Recipient_clone(orig: number): Recipient {
18348 if(!isWasmInitialized) {
18349 throw new Error("initializeWasm() must be awaited first!");
18351 const nativeResponseValue = wasm.TS_Recipient_clone(orig);
18352 return nativeResponseValue;
18354 // enum LDKRecipient Recipient_node(void);
18356 export function Recipient_node(): Recipient {
18357 if(!isWasmInitialized) {
18358 throw new Error("initializeWasm() must be awaited first!");
18360 const nativeResponseValue = wasm.TS_Recipient_node();
18361 return nativeResponseValue;
18363 // enum LDKRecipient Recipient_phantom_node(void);
18365 export function Recipient_phantom_node(): Recipient {
18366 if(!isWasmInitialized) {
18367 throw new Error("initializeWasm() must be awaited first!");
18369 const nativeResponseValue = wasm.TS_Recipient_phantom_node();
18370 return nativeResponseValue;
18372 // void KeysInterface_free(struct LDKKeysInterface this_ptr);
18374 export function KeysInterface_free(this_ptr: number): void {
18375 if(!isWasmInitialized) {
18376 throw new Error("initializeWasm() must be awaited first!");
18378 const nativeResponseValue = wasm.TS_KeysInterface_free(this_ptr);
18379 // debug statements here
18381 // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
18383 export function InMemorySigner_free(this_obj: number): void {
18384 if(!isWasmInitialized) {
18385 throw new Error("initializeWasm() must be awaited first!");
18387 const nativeResponseValue = wasm.TS_InMemorySigner_free(this_obj);
18388 // debug statements here
18390 // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18392 export function InMemorySigner_get_funding_key(this_ptr: number): number {
18393 if(!isWasmInitialized) {
18394 throw new Error("initializeWasm() must be awaited first!");
18396 const nativeResponseValue = wasm.TS_InMemorySigner_get_funding_key(this_ptr);
18397 return nativeResponseValue;
18399 // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18401 export function InMemorySigner_set_funding_key(this_ptr: number, val: number): void {
18402 if(!isWasmInitialized) {
18403 throw new Error("initializeWasm() must be awaited first!");
18405 const nativeResponseValue = wasm.TS_InMemorySigner_set_funding_key(this_ptr, val);
18406 // debug statements here
18408 // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18410 export function InMemorySigner_get_revocation_base_key(this_ptr: number): number {
18411 if(!isWasmInitialized) {
18412 throw new Error("initializeWasm() must be awaited first!");
18414 const nativeResponseValue = wasm.TS_InMemorySigner_get_revocation_base_key(this_ptr);
18415 return nativeResponseValue;
18417 // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18419 export function InMemorySigner_set_revocation_base_key(this_ptr: number, val: number): void {
18420 if(!isWasmInitialized) {
18421 throw new Error("initializeWasm() must be awaited first!");
18423 const nativeResponseValue = wasm.TS_InMemorySigner_set_revocation_base_key(this_ptr, val);
18424 // debug statements here
18426 // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18428 export function InMemorySigner_get_payment_key(this_ptr: number): number {
18429 if(!isWasmInitialized) {
18430 throw new Error("initializeWasm() must be awaited first!");
18432 const nativeResponseValue = wasm.TS_InMemorySigner_get_payment_key(this_ptr);
18433 return nativeResponseValue;
18435 // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18437 export function InMemorySigner_set_payment_key(this_ptr: number, val: number): void {
18438 if(!isWasmInitialized) {
18439 throw new Error("initializeWasm() must be awaited first!");
18441 const nativeResponseValue = wasm.TS_InMemorySigner_set_payment_key(this_ptr, val);
18442 // debug statements here
18444 // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18446 export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): number {
18447 if(!isWasmInitialized) {
18448 throw new Error("initializeWasm() must be awaited first!");
18450 const nativeResponseValue = wasm.TS_InMemorySigner_get_delayed_payment_base_key(this_ptr);
18451 return nativeResponseValue;
18453 // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18455 export function InMemorySigner_set_delayed_payment_base_key(this_ptr: number, val: number): void {
18456 if(!isWasmInitialized) {
18457 throw new Error("initializeWasm() must be awaited first!");
18459 const nativeResponseValue = wasm.TS_InMemorySigner_set_delayed_payment_base_key(this_ptr, val);
18460 // debug statements here
18462 // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18464 export function InMemorySigner_get_htlc_base_key(this_ptr: number): number {
18465 if(!isWasmInitialized) {
18466 throw new Error("initializeWasm() must be awaited first!");
18468 const nativeResponseValue = wasm.TS_InMemorySigner_get_htlc_base_key(this_ptr);
18469 return nativeResponseValue;
18471 // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val);
18473 export function InMemorySigner_set_htlc_base_key(this_ptr: number, val: number): void {
18474 if(!isWasmInitialized) {
18475 throw new Error("initializeWasm() must be awaited first!");
18477 const nativeResponseValue = wasm.TS_InMemorySigner_set_htlc_base_key(this_ptr, val);
18478 // debug statements here
18480 // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
18482 export function InMemorySigner_get_commitment_seed(this_ptr: number): number {
18483 if(!isWasmInitialized) {
18484 throw new Error("initializeWasm() must be awaited first!");
18486 const nativeResponseValue = wasm.TS_InMemorySigner_get_commitment_seed(this_ptr);
18487 return nativeResponseValue;
18489 // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
18491 export function InMemorySigner_set_commitment_seed(this_ptr: number, val: number): void {
18492 if(!isWasmInitialized) {
18493 throw new Error("initializeWasm() must be awaited first!");
18495 const nativeResponseValue = wasm.TS_InMemorySigner_set_commitment_seed(this_ptr, val);
18496 // debug statements here
18498 // uintptr_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg);
18500 export function InMemorySigner_clone_ptr(arg: number): number {
18501 if(!isWasmInitialized) {
18502 throw new Error("initializeWasm() must be awaited first!");
18504 const nativeResponseValue = wasm.TS_InMemorySigner_clone_ptr(arg);
18505 return nativeResponseValue;
18507 // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig);
18509 export function InMemorySigner_clone(orig: number): number {
18510 if(!isWasmInitialized) {
18511 throw new Error("initializeWasm() must be awaited first!");
18513 const nativeResponseValue = wasm.TS_InMemorySigner_clone(orig);
18514 return nativeResponseValue;
18516 // 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);
18518 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 {
18519 if(!isWasmInitialized) {
18520 throw new Error("initializeWasm() must be awaited first!");
18522 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);
18523 return nativeResponseValue;
18525 // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18527 export function InMemorySigner_counterparty_pubkeys(this_arg: number): number {
18528 if(!isWasmInitialized) {
18529 throw new Error("initializeWasm() must be awaited first!");
18531 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_pubkeys(this_arg);
18532 return nativeResponseValue;
18534 // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18536 export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number {
18537 if(!isWasmInitialized) {
18538 throw new Error("initializeWasm() must be awaited first!");
18540 const nativeResponseValue = wasm.TS_InMemorySigner_counterparty_selected_contest_delay(this_arg);
18541 return nativeResponseValue;
18543 // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18545 export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number {
18546 if(!isWasmInitialized) {
18547 throw new Error("initializeWasm() must be awaited first!");
18549 const nativeResponseValue = wasm.TS_InMemorySigner_holder_selected_contest_delay(this_arg);
18550 return nativeResponseValue;
18552 // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18554 export function InMemorySigner_is_outbound(this_arg: number): boolean {
18555 if(!isWasmInitialized) {
18556 throw new Error("initializeWasm() must be awaited first!");
18558 const nativeResponseValue = wasm.TS_InMemorySigner_is_outbound(this_arg);
18559 return nativeResponseValue;
18561 // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18563 export function InMemorySigner_funding_outpoint(this_arg: number): number {
18564 if(!isWasmInitialized) {
18565 throw new Error("initializeWasm() must be awaited first!");
18567 const nativeResponseValue = wasm.TS_InMemorySigner_funding_outpoint(this_arg);
18568 return nativeResponseValue;
18570 // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18572 export function InMemorySigner_get_channel_parameters(this_arg: number): number {
18573 if(!isWasmInitialized) {
18574 throw new Error("initializeWasm() must be awaited first!");
18576 const nativeResponseValue = wasm.TS_InMemorySigner_get_channel_parameters(this_arg);
18577 return nativeResponseValue;
18579 // MUST_USE_RES bool InMemorySigner_opt_anchors(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18581 export function InMemorySigner_opt_anchors(this_arg: number): boolean {
18582 if(!isWasmInitialized) {
18583 throw new Error("initializeWasm() must be awaited first!");
18585 const nativeResponseValue = wasm.TS_InMemorySigner_opt_anchors(this_arg);
18586 return nativeResponseValue;
18588 // 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);
18590 export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
18591 if(!isWasmInitialized) {
18592 throw new Error("initializeWasm() must be awaited first!");
18594 const nativeResponseValue = wasm.TS_InMemorySigner_sign_counterparty_payment_input(this_arg, spend_tx, input_idx, descriptor);
18595 return nativeResponseValue;
18597 // 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);
18599 export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: number, input_idx: number, descriptor: number): number {
18600 if(!isWasmInitialized) {
18601 throw new Error("initializeWasm() must be awaited first!");
18603 const nativeResponseValue = wasm.TS_InMemorySigner_sign_dynamic_p2wsh_input(this_arg, spend_tx, input_idx, descriptor);
18604 return nativeResponseValue;
18606 // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18608 export function InMemorySigner_as_BaseSign(this_arg: number): number {
18609 if(!isWasmInitialized) {
18610 throw new Error("initializeWasm() must be awaited first!");
18612 const nativeResponseValue = wasm.TS_InMemorySigner_as_BaseSign(this_arg);
18613 return nativeResponseValue;
18615 // struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
18617 export function InMemorySigner_as_Sign(this_arg: number): number {
18618 if(!isWasmInitialized) {
18619 throw new Error("initializeWasm() must be awaited first!");
18621 const nativeResponseValue = wasm.TS_InMemorySigner_as_Sign(this_arg);
18622 return nativeResponseValue;
18624 // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj);
18626 export function InMemorySigner_write(obj: number): number {
18627 if(!isWasmInitialized) {
18628 throw new Error("initializeWasm() must be awaited first!");
18630 const nativeResponseValue = wasm.TS_InMemorySigner_write(obj);
18631 return nativeResponseValue;
18633 // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser, struct LDKSecretKey arg);
18635 export function InMemorySigner_read(ser: number, arg: number): number {
18636 if(!isWasmInitialized) {
18637 throw new Error("initializeWasm() must be awaited first!");
18639 const nativeResponseValue = wasm.TS_InMemorySigner_read(ser, arg);
18640 return nativeResponseValue;
18642 // void KeysManager_free(struct LDKKeysManager this_obj);
18644 export function KeysManager_free(this_obj: number): void {
18645 if(!isWasmInitialized) {
18646 throw new Error("initializeWasm() must be awaited first!");
18648 const nativeResponseValue = wasm.TS_KeysManager_free(this_obj);
18649 // debug statements here
18651 // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
18653 export function KeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number): number {
18654 if(!isWasmInitialized) {
18655 throw new Error("initializeWasm() must be awaited first!");
18657 const nativeResponseValue = wasm.TS_KeysManager_new(seed, starting_time_secs, starting_time_nanos);
18658 return nativeResponseValue;
18660 // 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]);
18662 export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
18663 if(!isWasmInitialized) {
18664 throw new Error("initializeWasm() must be awaited first!");
18666 const nativeResponseValue = wasm.TS_KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
18667 return nativeResponseValue;
18669 // 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);
18671 export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
18672 if(!isWasmInitialized) {
18673 throw new Error("initializeWasm() must be awaited first!");
18675 const nativeResponseValue = wasm.TS_KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
18676 return nativeResponseValue;
18678 // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg);
18680 export function KeysManager_as_KeysInterface(this_arg: number): number {
18681 if(!isWasmInitialized) {
18682 throw new Error("initializeWasm() must be awaited first!");
18684 const nativeResponseValue = wasm.TS_KeysManager_as_KeysInterface(this_arg);
18685 return nativeResponseValue;
18687 // void PhantomKeysManager_free(struct LDKPhantomKeysManager this_obj);
18689 export function PhantomKeysManager_free(this_obj: number): void {
18690 if(!isWasmInitialized) {
18691 throw new Error("initializeWasm() must be awaited first!");
18693 const nativeResponseValue = wasm.TS_PhantomKeysManager_free(this_obj);
18694 // debug statements here
18696 // struct LDKKeysInterface PhantomKeysManager_as_KeysInterface(const struct LDKPhantomKeysManager *NONNULL_PTR this_arg);
18698 export function PhantomKeysManager_as_KeysInterface(this_arg: number): number {
18699 if(!isWasmInitialized) {
18700 throw new Error("initializeWasm() must be awaited first!");
18702 const nativeResponseValue = wasm.TS_PhantomKeysManager_as_KeysInterface(this_arg);
18703 return nativeResponseValue;
18705 // 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]);
18707 export function PhantomKeysManager_new(seed: number, starting_time_secs: bigint, starting_time_nanos: number, cross_node_seed: number): number {
18708 if(!isWasmInitialized) {
18709 throw new Error("initializeWasm() must be awaited first!");
18711 const nativeResponseValue = wasm.TS_PhantomKeysManager_new(seed, starting_time_secs, starting_time_nanos, cross_node_seed);
18712 return nativeResponseValue;
18714 // 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);
18716 export function PhantomKeysManager_spend_spendable_outputs(this_arg: number, descriptors: number, outputs: number, change_destination_script: number, feerate_sat_per_1000_weight: number): number {
18717 if(!isWasmInitialized) {
18718 throw new Error("initializeWasm() must be awaited first!");
18720 const nativeResponseValue = wasm.TS_PhantomKeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, change_destination_script, feerate_sat_per_1000_weight);
18721 return nativeResponseValue;
18723 // 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]);
18725 export function PhantomKeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: bigint, params: number): number {
18726 if(!isWasmInitialized) {
18727 throw new Error("initializeWasm() must be awaited first!");
18729 const nativeResponseValue = wasm.TS_PhantomKeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params);
18730 return nativeResponseValue;
18732 // void ChannelManager_free(struct LDKChannelManager this_obj);
18734 export function ChannelManager_free(this_obj: number): void {
18735 if(!isWasmInitialized) {
18736 throw new Error("initializeWasm() must be awaited first!");
18738 const nativeResponseValue = wasm.TS_ChannelManager_free(this_obj);
18739 // debug statements here
18741 // void ChainParameters_free(struct LDKChainParameters this_obj);
18743 export function ChainParameters_free(this_obj: number): void {
18744 if(!isWasmInitialized) {
18745 throw new Error("initializeWasm() must be awaited first!");
18747 const nativeResponseValue = wasm.TS_ChainParameters_free(this_obj);
18748 // debug statements here
18750 // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
18752 export function ChainParameters_get_network(this_ptr: number): Network {
18753 if(!isWasmInitialized) {
18754 throw new Error("initializeWasm() must be awaited first!");
18756 const nativeResponseValue = wasm.TS_ChainParameters_get_network(this_ptr);
18757 return nativeResponseValue;
18759 // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val);
18761 export function ChainParameters_set_network(this_ptr: number, val: Network): void {
18762 if(!isWasmInitialized) {
18763 throw new Error("initializeWasm() must be awaited first!");
18765 const nativeResponseValue = wasm.TS_ChainParameters_set_network(this_ptr, val);
18766 // debug statements here
18768 // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
18770 export function ChainParameters_get_best_block(this_ptr: number): number {
18771 if(!isWasmInitialized) {
18772 throw new Error("initializeWasm() must be awaited first!");
18774 const nativeResponseValue = wasm.TS_ChainParameters_get_best_block(this_ptr);
18775 return nativeResponseValue;
18777 // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
18779 export function ChainParameters_set_best_block(this_ptr: number, val: number): void {
18780 if(!isWasmInitialized) {
18781 throw new Error("initializeWasm() must be awaited first!");
18783 const nativeResponseValue = wasm.TS_ChainParameters_set_best_block(this_ptr, val);
18784 // debug statements here
18786 // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
18788 export function ChainParameters_new(network_arg: Network, best_block_arg: number): number {
18789 if(!isWasmInitialized) {
18790 throw new Error("initializeWasm() must be awaited first!");
18792 const nativeResponseValue = wasm.TS_ChainParameters_new(network_arg, best_block_arg);
18793 return nativeResponseValue;
18795 // uintptr_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg);
18797 export function ChainParameters_clone_ptr(arg: number): number {
18798 if(!isWasmInitialized) {
18799 throw new Error("initializeWasm() must be awaited first!");
18801 const nativeResponseValue = wasm.TS_ChainParameters_clone_ptr(arg);
18802 return nativeResponseValue;
18804 // struct LDKChainParameters ChainParameters_clone(const struct LDKChainParameters *NONNULL_PTR orig);
18806 export function ChainParameters_clone(orig: number): number {
18807 if(!isWasmInitialized) {
18808 throw new Error("initializeWasm() must be awaited first!");
18810 const nativeResponseValue = wasm.TS_ChainParameters_clone(orig);
18811 return nativeResponseValue;
18813 // void CounterpartyForwardingInfo_free(struct LDKCounterpartyForwardingInfo this_obj);
18815 export function CounterpartyForwardingInfo_free(this_obj: number): void {
18816 if(!isWasmInitialized) {
18817 throw new Error("initializeWasm() must be awaited first!");
18819 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_free(this_obj);
18820 // debug statements here
18822 // uint32_t CounterpartyForwardingInfo_get_fee_base_msat(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18824 export function CounterpartyForwardingInfo_get_fee_base_msat(this_ptr: number): number {
18825 if(!isWasmInitialized) {
18826 throw new Error("initializeWasm() must be awaited first!");
18828 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_base_msat(this_ptr);
18829 return nativeResponseValue;
18831 // void CounterpartyForwardingInfo_set_fee_base_msat(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
18833 export function CounterpartyForwardingInfo_set_fee_base_msat(this_ptr: number, val: number): void {
18834 if(!isWasmInitialized) {
18835 throw new Error("initializeWasm() must be awaited first!");
18837 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_base_msat(this_ptr, val);
18838 // debug statements here
18840 // uint32_t CounterpartyForwardingInfo_get_fee_proportional_millionths(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18842 export function CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr: number): number {
18843 if(!isWasmInitialized) {
18844 throw new Error("initializeWasm() must be awaited first!");
18846 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(this_ptr);
18847 return nativeResponseValue;
18849 // void CounterpartyForwardingInfo_set_fee_proportional_millionths(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint32_t val);
18851 export function CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr: number, val: number): void {
18852 if(!isWasmInitialized) {
18853 throw new Error("initializeWasm() must be awaited first!");
18855 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(this_ptr, val);
18856 // debug statements here
18858 // uint16_t CounterpartyForwardingInfo_get_cltv_expiry_delta(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr);
18860 export function CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr: number): number {
18861 if(!isWasmInitialized) {
18862 throw new Error("initializeWasm() must be awaited first!");
18864 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(this_ptr);
18865 return nativeResponseValue;
18867 // void CounterpartyForwardingInfo_set_cltv_expiry_delta(struct LDKCounterpartyForwardingInfo *NONNULL_PTR this_ptr, uint16_t val);
18869 export function CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
18870 if(!isWasmInitialized) {
18871 throw new Error("initializeWasm() must be awaited first!");
18873 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(this_ptr, val);
18874 // debug statements here
18876 // 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);
18878 export function CounterpartyForwardingInfo_new(fee_base_msat_arg: number, fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number): number {
18879 if(!isWasmInitialized) {
18880 throw new Error("initializeWasm() must be awaited first!");
18882 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
18883 return nativeResponseValue;
18885 // uintptr_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg);
18887 export function CounterpartyForwardingInfo_clone_ptr(arg: number): number {
18888 if(!isWasmInitialized) {
18889 throw new Error("initializeWasm() must be awaited first!");
18891 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone_ptr(arg);
18892 return nativeResponseValue;
18894 // struct LDKCounterpartyForwardingInfo CounterpartyForwardingInfo_clone(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR orig);
18896 export function CounterpartyForwardingInfo_clone(orig: number): number {
18897 if(!isWasmInitialized) {
18898 throw new Error("initializeWasm() must be awaited first!");
18900 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_clone(orig);
18901 return nativeResponseValue;
18903 // void ChannelCounterparty_free(struct LDKChannelCounterparty this_obj);
18905 export function ChannelCounterparty_free(this_obj: number): void {
18906 if(!isWasmInitialized) {
18907 throw new Error("initializeWasm() must be awaited first!");
18909 const nativeResponseValue = wasm.TS_ChannelCounterparty_free(this_obj);
18910 // debug statements here
18912 // struct LDKPublicKey ChannelCounterparty_get_node_id(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18914 export function ChannelCounterparty_get_node_id(this_ptr: number): number {
18915 if(!isWasmInitialized) {
18916 throw new Error("initializeWasm() must be awaited first!");
18918 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_node_id(this_ptr);
18919 return nativeResponseValue;
18921 // void ChannelCounterparty_set_node_id(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKPublicKey val);
18923 export function ChannelCounterparty_set_node_id(this_ptr: number, val: number): void {
18924 if(!isWasmInitialized) {
18925 throw new Error("initializeWasm() must be awaited first!");
18927 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_node_id(this_ptr, val);
18928 // debug statements here
18930 // struct LDKInitFeatures ChannelCounterparty_get_features(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18932 export function ChannelCounterparty_get_features(this_ptr: number): number {
18933 if(!isWasmInitialized) {
18934 throw new Error("initializeWasm() must be awaited first!");
18936 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_features(this_ptr);
18937 return nativeResponseValue;
18939 // void ChannelCounterparty_set_features(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
18941 export function ChannelCounterparty_set_features(this_ptr: number, val: number): void {
18942 if(!isWasmInitialized) {
18943 throw new Error("initializeWasm() must be awaited first!");
18945 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_features(this_ptr, val);
18946 // debug statements here
18948 // uint64_t ChannelCounterparty_get_unspendable_punishment_reserve(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18950 export function ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr: number): bigint {
18951 if(!isWasmInitialized) {
18952 throw new Error("initializeWasm() must be awaited first!");
18954 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_unspendable_punishment_reserve(this_ptr);
18955 return nativeResponseValue;
18957 // void ChannelCounterparty_set_unspendable_punishment_reserve(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, uint64_t val);
18959 export function ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr: number, val: bigint): void {
18960 if(!isWasmInitialized) {
18961 throw new Error("initializeWasm() must be awaited first!");
18963 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_unspendable_punishment_reserve(this_ptr, val);
18964 // debug statements here
18966 // struct LDKCounterpartyForwardingInfo ChannelCounterparty_get_forwarding_info(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18968 export function ChannelCounterparty_get_forwarding_info(this_ptr: number): number {
18969 if(!isWasmInitialized) {
18970 throw new Error("initializeWasm() must be awaited first!");
18972 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_forwarding_info(this_ptr);
18973 return nativeResponseValue;
18975 // void ChannelCounterparty_set_forwarding_info(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCounterpartyForwardingInfo val);
18977 export function ChannelCounterparty_set_forwarding_info(this_ptr: number, val: number): void {
18978 if(!isWasmInitialized) {
18979 throw new Error("initializeWasm() must be awaited first!");
18981 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_forwarding_info(this_ptr, val);
18982 // debug statements here
18984 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_minimum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
18986 export function ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr: number): number {
18987 if(!isWasmInitialized) {
18988 throw new Error("initializeWasm() must be awaited first!");
18990 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(this_ptr);
18991 return nativeResponseValue;
18993 // void ChannelCounterparty_set_outbound_htlc_minimum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
18995 export function ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr: number, val: number): void {
18996 if(!isWasmInitialized) {
18997 throw new Error("initializeWasm() must be awaited first!");
18999 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(this_ptr, val);
19000 // debug statements here
19002 // struct LDKCOption_u64Z ChannelCounterparty_get_outbound_htlc_maximum_msat(const struct LDKChannelCounterparty *NONNULL_PTR this_ptr);
19004 export function ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr: number): number {
19005 if(!isWasmInitialized) {
19006 throw new Error("initializeWasm() must be awaited first!");
19008 const nativeResponseValue = wasm.TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(this_ptr);
19009 return nativeResponseValue;
19011 // void ChannelCounterparty_set_outbound_htlc_maximum_msat(struct LDKChannelCounterparty *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19013 export function ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr: number, val: number): void {
19014 if(!isWasmInitialized) {
19015 throw new Error("initializeWasm() must be awaited first!");
19017 const nativeResponseValue = wasm.TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(this_ptr, val);
19018 // debug statements here
19020 // 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);
19022 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 {
19023 if(!isWasmInitialized) {
19024 throw new Error("initializeWasm() must be awaited first!");
19026 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);
19027 return nativeResponseValue;
19029 // uintptr_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg);
19031 export function ChannelCounterparty_clone_ptr(arg: number): number {
19032 if(!isWasmInitialized) {
19033 throw new Error("initializeWasm() must be awaited first!");
19035 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone_ptr(arg);
19036 return nativeResponseValue;
19038 // struct LDKChannelCounterparty ChannelCounterparty_clone(const struct LDKChannelCounterparty *NONNULL_PTR orig);
19040 export function ChannelCounterparty_clone(orig: number): number {
19041 if(!isWasmInitialized) {
19042 throw new Error("initializeWasm() must be awaited first!");
19044 const nativeResponseValue = wasm.TS_ChannelCounterparty_clone(orig);
19045 return nativeResponseValue;
19047 // void ChannelDetails_free(struct LDKChannelDetails this_obj);
19049 export function ChannelDetails_free(this_obj: number): void {
19050 if(!isWasmInitialized) {
19051 throw new Error("initializeWasm() must be awaited first!");
19053 const nativeResponseValue = wasm.TS_ChannelDetails_free(this_obj);
19054 // debug statements here
19056 // const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
19058 export function ChannelDetails_get_channel_id(this_ptr: number): number {
19059 if(!isWasmInitialized) {
19060 throw new Error("initializeWasm() must be awaited first!");
19062 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_id(this_ptr);
19063 return nativeResponseValue;
19065 // void ChannelDetails_set_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
19067 export function ChannelDetails_set_channel_id(this_ptr: number, val: number): void {
19068 if(!isWasmInitialized) {
19069 throw new Error("initializeWasm() must be awaited first!");
19071 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_id(this_ptr, val);
19072 // debug statements here
19074 // struct LDKChannelCounterparty ChannelDetails_get_counterparty(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19076 export function ChannelDetails_get_counterparty(this_ptr: number): number {
19077 if(!isWasmInitialized) {
19078 throw new Error("initializeWasm() must be awaited first!");
19080 const nativeResponseValue = wasm.TS_ChannelDetails_get_counterparty(this_ptr);
19081 return nativeResponseValue;
19083 // void ChannelDetails_set_counterparty(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelCounterparty val);
19085 export function ChannelDetails_set_counterparty(this_ptr: number, val: number): void {
19086 if(!isWasmInitialized) {
19087 throw new Error("initializeWasm() must be awaited first!");
19089 const nativeResponseValue = wasm.TS_ChannelDetails_set_counterparty(this_ptr, val);
19090 // debug statements here
19092 // struct LDKOutPoint ChannelDetails_get_funding_txo(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19094 export function ChannelDetails_get_funding_txo(this_ptr: number): number {
19095 if(!isWasmInitialized) {
19096 throw new Error("initializeWasm() must be awaited first!");
19098 const nativeResponseValue = wasm.TS_ChannelDetails_get_funding_txo(this_ptr);
19099 return nativeResponseValue;
19101 // void ChannelDetails_set_funding_txo(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKOutPoint val);
19103 export function ChannelDetails_set_funding_txo(this_ptr: number, val: number): void {
19104 if(!isWasmInitialized) {
19105 throw new Error("initializeWasm() must be awaited first!");
19107 const nativeResponseValue = wasm.TS_ChannelDetails_set_funding_txo(this_ptr, val);
19108 // debug statements here
19110 // struct LDKChannelTypeFeatures ChannelDetails_get_channel_type(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19112 export function ChannelDetails_get_channel_type(this_ptr: number): number {
19113 if(!isWasmInitialized) {
19114 throw new Error("initializeWasm() must be awaited first!");
19116 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_type(this_ptr);
19117 return nativeResponseValue;
19119 // void ChannelDetails_set_channel_type(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
19121 export function ChannelDetails_set_channel_type(this_ptr: number, val: number): void {
19122 if(!isWasmInitialized) {
19123 throw new Error("initializeWasm() must be awaited first!");
19125 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_type(this_ptr, val);
19126 // debug statements here
19128 // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19130 export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
19131 if(!isWasmInitialized) {
19132 throw new Error("initializeWasm() must be awaited first!");
19134 const nativeResponseValue = wasm.TS_ChannelDetails_get_short_channel_id(this_ptr);
19135 return nativeResponseValue;
19137 // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19139 export function ChannelDetails_set_short_channel_id(this_ptr: number, val: number): void {
19140 if(!isWasmInitialized) {
19141 throw new Error("initializeWasm() must be awaited first!");
19143 const nativeResponseValue = wasm.TS_ChannelDetails_set_short_channel_id(this_ptr, val);
19144 // debug statements here
19146 // struct LDKCOption_u64Z ChannelDetails_get_outbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19148 export function ChannelDetails_get_outbound_scid_alias(this_ptr: number): number {
19149 if(!isWasmInitialized) {
19150 throw new Error("initializeWasm() must be awaited first!");
19152 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_scid_alias(this_ptr);
19153 return nativeResponseValue;
19155 // void ChannelDetails_set_outbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19157 export function ChannelDetails_set_outbound_scid_alias(this_ptr: number, val: number): void {
19158 if(!isWasmInitialized) {
19159 throw new Error("initializeWasm() must be awaited first!");
19161 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_scid_alias(this_ptr, val);
19162 // debug statements here
19164 // struct LDKCOption_u64Z ChannelDetails_get_inbound_scid_alias(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19166 export function ChannelDetails_get_inbound_scid_alias(this_ptr: number): number {
19167 if(!isWasmInitialized) {
19168 throw new Error("initializeWasm() must be awaited first!");
19170 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_scid_alias(this_ptr);
19171 return nativeResponseValue;
19173 // void ChannelDetails_set_inbound_scid_alias(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19175 export function ChannelDetails_set_inbound_scid_alias(this_ptr: number, val: number): void {
19176 if(!isWasmInitialized) {
19177 throw new Error("initializeWasm() must be awaited first!");
19179 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_scid_alias(this_ptr, val);
19180 // debug statements here
19182 // uint64_t ChannelDetails_get_channel_value_satoshis(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19184 export function ChannelDetails_get_channel_value_satoshis(this_ptr: number): bigint {
19185 if(!isWasmInitialized) {
19186 throw new Error("initializeWasm() must be awaited first!");
19188 const nativeResponseValue = wasm.TS_ChannelDetails_get_channel_value_satoshis(this_ptr);
19189 return nativeResponseValue;
19191 // void ChannelDetails_set_channel_value_satoshis(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19193 export function ChannelDetails_set_channel_value_satoshis(this_ptr: number, val: bigint): void {
19194 if(!isWasmInitialized) {
19195 throw new Error("initializeWasm() must be awaited first!");
19197 const nativeResponseValue = wasm.TS_ChannelDetails_set_channel_value_satoshis(this_ptr, val);
19198 // debug statements here
19200 // struct LDKCOption_u64Z ChannelDetails_get_unspendable_punishment_reserve(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19202 export function ChannelDetails_get_unspendable_punishment_reserve(this_ptr: number): number {
19203 if(!isWasmInitialized) {
19204 throw new Error("initializeWasm() must be awaited first!");
19206 const nativeResponseValue = wasm.TS_ChannelDetails_get_unspendable_punishment_reserve(this_ptr);
19207 return nativeResponseValue;
19209 // void ChannelDetails_set_unspendable_punishment_reserve(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19211 export function ChannelDetails_set_unspendable_punishment_reserve(this_ptr: number, val: number): void {
19212 if(!isWasmInitialized) {
19213 throw new Error("initializeWasm() must be awaited first!");
19215 const nativeResponseValue = wasm.TS_ChannelDetails_set_unspendable_punishment_reserve(this_ptr, val);
19216 // debug statements here
19218 // uint64_t ChannelDetails_get_user_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19220 export function ChannelDetails_get_user_channel_id(this_ptr: number): bigint {
19221 if(!isWasmInitialized) {
19222 throw new Error("initializeWasm() must be awaited first!");
19224 const nativeResponseValue = wasm.TS_ChannelDetails_get_user_channel_id(this_ptr);
19225 return nativeResponseValue;
19227 // void ChannelDetails_set_user_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19229 export function ChannelDetails_set_user_channel_id(this_ptr: number, val: bigint): void {
19230 if(!isWasmInitialized) {
19231 throw new Error("initializeWasm() must be awaited first!");
19233 const nativeResponseValue = wasm.TS_ChannelDetails_set_user_channel_id(this_ptr, val);
19234 // debug statements here
19236 // uint64_t ChannelDetails_get_balance_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19238 export function ChannelDetails_get_balance_msat(this_ptr: number): bigint {
19239 if(!isWasmInitialized) {
19240 throw new Error("initializeWasm() must be awaited first!");
19242 const nativeResponseValue = wasm.TS_ChannelDetails_get_balance_msat(this_ptr);
19243 return nativeResponseValue;
19245 // void ChannelDetails_set_balance_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19247 export function ChannelDetails_set_balance_msat(this_ptr: number, val: bigint): void {
19248 if(!isWasmInitialized) {
19249 throw new Error("initializeWasm() must be awaited first!");
19251 const nativeResponseValue = wasm.TS_ChannelDetails_set_balance_msat(this_ptr, val);
19252 // debug statements here
19254 // uint64_t ChannelDetails_get_outbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19256 export function ChannelDetails_get_outbound_capacity_msat(this_ptr: number): bigint {
19257 if(!isWasmInitialized) {
19258 throw new Error("initializeWasm() must be awaited first!");
19260 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_capacity_msat(this_ptr);
19261 return nativeResponseValue;
19263 // void ChannelDetails_set_outbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19265 export function ChannelDetails_set_outbound_capacity_msat(this_ptr: number, val: bigint): void {
19266 if(!isWasmInitialized) {
19267 throw new Error("initializeWasm() must be awaited first!");
19269 const nativeResponseValue = wasm.TS_ChannelDetails_set_outbound_capacity_msat(this_ptr, val);
19270 // debug statements here
19272 // uint64_t ChannelDetails_get_next_outbound_htlc_limit_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19274 export function ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr: number): bigint {
19275 if(!isWasmInitialized) {
19276 throw new Error("initializeWasm() must be awaited first!");
19278 const nativeResponseValue = wasm.TS_ChannelDetails_get_next_outbound_htlc_limit_msat(this_ptr);
19279 return nativeResponseValue;
19281 // void ChannelDetails_set_next_outbound_htlc_limit_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19283 export function ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr: number, val: bigint): void {
19284 if(!isWasmInitialized) {
19285 throw new Error("initializeWasm() must be awaited first!");
19287 const nativeResponseValue = wasm.TS_ChannelDetails_set_next_outbound_htlc_limit_msat(this_ptr, val);
19288 // debug statements here
19290 // uint64_t ChannelDetails_get_inbound_capacity_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19292 export function ChannelDetails_get_inbound_capacity_msat(this_ptr: number): bigint {
19293 if(!isWasmInitialized) {
19294 throw new Error("initializeWasm() must be awaited first!");
19296 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_capacity_msat(this_ptr);
19297 return nativeResponseValue;
19299 // void ChannelDetails_set_inbound_capacity_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, uint64_t val);
19301 export function ChannelDetails_set_inbound_capacity_msat(this_ptr: number, val: bigint): void {
19302 if(!isWasmInitialized) {
19303 throw new Error("initializeWasm() must be awaited first!");
19305 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_capacity_msat(this_ptr, val);
19306 // debug statements here
19308 // struct LDKCOption_u32Z ChannelDetails_get_confirmations_required(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19310 export function ChannelDetails_get_confirmations_required(this_ptr: number): number {
19311 if(!isWasmInitialized) {
19312 throw new Error("initializeWasm() must be awaited first!");
19314 const nativeResponseValue = wasm.TS_ChannelDetails_get_confirmations_required(this_ptr);
19315 return nativeResponseValue;
19317 // void ChannelDetails_set_confirmations_required(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
19319 export function ChannelDetails_set_confirmations_required(this_ptr: number, val: number): void {
19320 if(!isWasmInitialized) {
19321 throw new Error("initializeWasm() must be awaited first!");
19323 const nativeResponseValue = wasm.TS_ChannelDetails_set_confirmations_required(this_ptr, val);
19324 // debug statements here
19326 // struct LDKCOption_u16Z ChannelDetails_get_force_close_spend_delay(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19328 export function ChannelDetails_get_force_close_spend_delay(this_ptr: number): number {
19329 if(!isWasmInitialized) {
19330 throw new Error("initializeWasm() must be awaited first!");
19332 const nativeResponseValue = wasm.TS_ChannelDetails_get_force_close_spend_delay(this_ptr);
19333 return nativeResponseValue;
19335 // void ChannelDetails_set_force_close_spend_delay(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u16Z val);
19337 export function ChannelDetails_set_force_close_spend_delay(this_ptr: number, val: number): void {
19338 if(!isWasmInitialized) {
19339 throw new Error("initializeWasm() must be awaited first!");
19341 const nativeResponseValue = wasm.TS_ChannelDetails_set_force_close_spend_delay(this_ptr, val);
19342 // debug statements here
19344 // bool ChannelDetails_get_is_outbound(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19346 export function ChannelDetails_get_is_outbound(this_ptr: number): boolean {
19347 if(!isWasmInitialized) {
19348 throw new Error("initializeWasm() must be awaited first!");
19350 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_outbound(this_ptr);
19351 return nativeResponseValue;
19353 // void ChannelDetails_set_is_outbound(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19355 export function ChannelDetails_set_is_outbound(this_ptr: number, val: boolean): void {
19356 if(!isWasmInitialized) {
19357 throw new Error("initializeWasm() must be awaited first!");
19359 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_outbound(this_ptr, val);
19360 // debug statements here
19362 // bool ChannelDetails_get_is_channel_ready(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19364 export function ChannelDetails_get_is_channel_ready(this_ptr: number): boolean {
19365 if(!isWasmInitialized) {
19366 throw new Error("initializeWasm() must be awaited first!");
19368 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_channel_ready(this_ptr);
19369 return nativeResponseValue;
19371 // void ChannelDetails_set_is_channel_ready(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19373 export function ChannelDetails_set_is_channel_ready(this_ptr: number, val: boolean): void {
19374 if(!isWasmInitialized) {
19375 throw new Error("initializeWasm() must be awaited first!");
19377 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_channel_ready(this_ptr, val);
19378 // debug statements here
19380 // bool ChannelDetails_get_is_usable(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19382 export function ChannelDetails_get_is_usable(this_ptr: number): boolean {
19383 if(!isWasmInitialized) {
19384 throw new Error("initializeWasm() must be awaited first!");
19386 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_usable(this_ptr);
19387 return nativeResponseValue;
19389 // void ChannelDetails_set_is_usable(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19391 export function ChannelDetails_set_is_usable(this_ptr: number, val: boolean): void {
19392 if(!isWasmInitialized) {
19393 throw new Error("initializeWasm() must be awaited first!");
19395 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_usable(this_ptr, val);
19396 // debug statements here
19398 // bool ChannelDetails_get_is_public(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19400 export function ChannelDetails_get_is_public(this_ptr: number): boolean {
19401 if(!isWasmInitialized) {
19402 throw new Error("initializeWasm() must be awaited first!");
19404 const nativeResponseValue = wasm.TS_ChannelDetails_get_is_public(this_ptr);
19405 return nativeResponseValue;
19407 // void ChannelDetails_set_is_public(struct LDKChannelDetails *NONNULL_PTR this_ptr, bool val);
19409 export function ChannelDetails_set_is_public(this_ptr: number, val: boolean): void {
19410 if(!isWasmInitialized) {
19411 throw new Error("initializeWasm() must be awaited first!");
19413 const nativeResponseValue = wasm.TS_ChannelDetails_set_is_public(this_ptr, val);
19414 // debug statements here
19416 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_minimum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19418 export function ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr: number): number {
19419 if(!isWasmInitialized) {
19420 throw new Error("initializeWasm() must be awaited first!");
19422 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_minimum_msat(this_ptr);
19423 return nativeResponseValue;
19425 // void ChannelDetails_set_inbound_htlc_minimum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19427 export function ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr: number, val: number): void {
19428 if(!isWasmInitialized) {
19429 throw new Error("initializeWasm() must be awaited first!");
19431 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_minimum_msat(this_ptr, val);
19432 // debug statements here
19434 // struct LDKCOption_u64Z ChannelDetails_get_inbound_htlc_maximum_msat(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19436 export function ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr: number): number {
19437 if(!isWasmInitialized) {
19438 throw new Error("initializeWasm() must be awaited first!");
19440 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_htlc_maximum_msat(this_ptr);
19441 return nativeResponseValue;
19443 // void ChannelDetails_set_inbound_htlc_maximum_msat(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
19445 export function ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr: number, val: number): void {
19446 if(!isWasmInitialized) {
19447 throw new Error("initializeWasm() must be awaited first!");
19449 const nativeResponseValue = wasm.TS_ChannelDetails_set_inbound_htlc_maximum_msat(this_ptr, val);
19450 // debug statements here
19452 // struct LDKChannelConfig ChannelDetails_get_config(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
19454 export function ChannelDetails_get_config(this_ptr: number): number {
19455 if(!isWasmInitialized) {
19456 throw new Error("initializeWasm() must be awaited first!");
19458 const nativeResponseValue = wasm.TS_ChannelDetails_get_config(this_ptr);
19459 return nativeResponseValue;
19461 // void ChannelDetails_set_config(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKChannelConfig val);
19463 export function ChannelDetails_set_config(this_ptr: number, val: number): void {
19464 if(!isWasmInitialized) {
19465 throw new Error("initializeWasm() must be awaited first!");
19467 const nativeResponseValue = wasm.TS_ChannelDetails_set_config(this_ptr, val);
19468 // debug statements here
19470 // MUST_USE_RES struct LDKChannelDetails ChannelDetails_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKChannelCounterparty counterparty_arg, struct LDKOutPoint funding_txo_arg, struct LDKChannelTypeFeatures channel_type_arg, struct LDKCOption_u64Z short_channel_id_arg, struct LDKCOption_u64Z outbound_scid_alias_arg, struct LDKCOption_u64Z inbound_scid_alias_arg, uint64_t channel_value_satoshis_arg, struct LDKCOption_u64Z unspendable_punishment_reserve_arg, uint64_t user_channel_id_arg, uint64_t balance_msat_arg, uint64_t outbound_capacity_msat_arg, uint64_t next_outbound_htlc_limit_msat_arg, uint64_t inbound_capacity_msat_arg, struct LDKCOption_u32Z confirmations_required_arg, struct LDKCOption_u16Z force_close_spend_delay_arg, bool is_outbound_arg, bool is_channel_ready_arg, bool is_usable_arg, bool is_public_arg, struct LDKCOption_u64Z inbound_htlc_minimum_msat_arg, struct LDKCOption_u64Z inbound_htlc_maximum_msat_arg, struct LDKChannelConfig config_arg);
19472 export function ChannelDetails_new(channel_id_arg: number, counterparty_arg: number, funding_txo_arg: number, channel_type_arg: number, short_channel_id_arg: number, outbound_scid_alias_arg: number, inbound_scid_alias_arg: number, channel_value_satoshis_arg: bigint, unspendable_punishment_reserve_arg: number, user_channel_id_arg: bigint, balance_msat_arg: bigint, outbound_capacity_msat_arg: bigint, next_outbound_htlc_limit_msat_arg: bigint, inbound_capacity_msat_arg: bigint, confirmations_required_arg: number, force_close_spend_delay_arg: number, is_outbound_arg: boolean, is_channel_ready_arg: boolean, is_usable_arg: boolean, is_public_arg: boolean, inbound_htlc_minimum_msat_arg: number, inbound_htlc_maximum_msat_arg: number, config_arg: number): number {
19473 if(!isWasmInitialized) {
19474 throw new Error("initializeWasm() must be awaited first!");
19476 const nativeResponseValue = wasm.TS_ChannelDetails_new(channel_id_arg, counterparty_arg, funding_txo_arg, channel_type_arg, short_channel_id_arg, outbound_scid_alias_arg, inbound_scid_alias_arg, channel_value_satoshis_arg, unspendable_punishment_reserve_arg, user_channel_id_arg, balance_msat_arg, outbound_capacity_msat_arg, next_outbound_htlc_limit_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg, force_close_spend_delay_arg, is_outbound_arg, is_channel_ready_arg, is_usable_arg, is_public_arg, inbound_htlc_minimum_msat_arg, inbound_htlc_maximum_msat_arg, config_arg);
19477 return nativeResponseValue;
19479 // uintptr_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg);
19481 export function ChannelDetails_clone_ptr(arg: number): number {
19482 if(!isWasmInitialized) {
19483 throw new Error("initializeWasm() must be awaited first!");
19485 const nativeResponseValue = wasm.TS_ChannelDetails_clone_ptr(arg);
19486 return nativeResponseValue;
19488 // struct LDKChannelDetails ChannelDetails_clone(const struct LDKChannelDetails *NONNULL_PTR orig);
19490 export function ChannelDetails_clone(orig: number): number {
19491 if(!isWasmInitialized) {
19492 throw new Error("initializeWasm() must be awaited first!");
19494 const nativeResponseValue = wasm.TS_ChannelDetails_clone(orig);
19495 return nativeResponseValue;
19497 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_inbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
19499 export function ChannelDetails_get_inbound_payment_scid(this_arg: number): number {
19500 if(!isWasmInitialized) {
19501 throw new Error("initializeWasm() must be awaited first!");
19503 const nativeResponseValue = wasm.TS_ChannelDetails_get_inbound_payment_scid(this_arg);
19504 return nativeResponseValue;
19506 // MUST_USE_RES struct LDKCOption_u64Z ChannelDetails_get_outbound_payment_scid(const struct LDKChannelDetails *NONNULL_PTR this_arg);
19508 export function ChannelDetails_get_outbound_payment_scid(this_arg: number): number {
19509 if(!isWasmInitialized) {
19510 throw new Error("initializeWasm() must be awaited first!");
19512 const nativeResponseValue = wasm.TS_ChannelDetails_get_outbound_payment_scid(this_arg);
19513 return nativeResponseValue;
19515 // void PaymentSendFailure_free(struct LDKPaymentSendFailure this_ptr);
19517 export function PaymentSendFailure_free(this_ptr: number): void {
19518 if(!isWasmInitialized) {
19519 throw new Error("initializeWasm() must be awaited first!");
19521 const nativeResponseValue = wasm.TS_PaymentSendFailure_free(this_ptr);
19522 // debug statements here
19524 // uintptr_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg);
19526 export function PaymentSendFailure_clone_ptr(arg: number): number {
19527 if(!isWasmInitialized) {
19528 throw new Error("initializeWasm() must be awaited first!");
19530 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone_ptr(arg);
19531 return nativeResponseValue;
19533 // struct LDKPaymentSendFailure PaymentSendFailure_clone(const struct LDKPaymentSendFailure *NONNULL_PTR orig);
19535 export function PaymentSendFailure_clone(orig: number): number {
19536 if(!isWasmInitialized) {
19537 throw new Error("initializeWasm() must be awaited first!");
19539 const nativeResponseValue = wasm.TS_PaymentSendFailure_clone(orig);
19540 return nativeResponseValue;
19542 // struct LDKPaymentSendFailure PaymentSendFailure_parameter_error(struct LDKAPIError a);
19544 export function PaymentSendFailure_parameter_error(a: number): number {
19545 if(!isWasmInitialized) {
19546 throw new Error("initializeWasm() must be awaited first!");
19548 const nativeResponseValue = wasm.TS_PaymentSendFailure_parameter_error(a);
19549 return nativeResponseValue;
19551 // struct LDKPaymentSendFailure PaymentSendFailure_path_parameter_error(struct LDKCVec_CResult_NoneAPIErrorZZ a);
19553 export function PaymentSendFailure_path_parameter_error(a: number): number {
19554 if(!isWasmInitialized) {
19555 throw new Error("initializeWasm() must be awaited first!");
19557 const nativeResponseValue = wasm.TS_PaymentSendFailure_path_parameter_error(a);
19558 return nativeResponseValue;
19560 // struct LDKPaymentSendFailure PaymentSendFailure_all_failed_retry_safe(struct LDKCVec_APIErrorZ a);
19562 export function PaymentSendFailure_all_failed_retry_safe(a: number): number {
19563 if(!isWasmInitialized) {
19564 throw new Error("initializeWasm() must be awaited first!");
19566 const nativeResponseValue = wasm.TS_PaymentSendFailure_all_failed_retry_safe(a);
19567 return nativeResponseValue;
19569 // struct LDKPaymentSendFailure PaymentSendFailure_partial_failure(struct LDKCVec_CResult_NoneAPIErrorZZ results, struct LDKRouteParameters failed_paths_retry, struct LDKThirtyTwoBytes payment_id);
19571 export function PaymentSendFailure_partial_failure(results: number, failed_paths_retry: number, payment_id: number): number {
19572 if(!isWasmInitialized) {
19573 throw new Error("initializeWasm() must be awaited first!");
19575 const nativeResponseValue = wasm.TS_PaymentSendFailure_partial_failure(results, failed_paths_retry, payment_id);
19576 return nativeResponseValue;
19578 // void PhantomRouteHints_free(struct LDKPhantomRouteHints this_obj);
19580 export function PhantomRouteHints_free(this_obj: number): void {
19581 if(!isWasmInitialized) {
19582 throw new Error("initializeWasm() must be awaited first!");
19584 const nativeResponseValue = wasm.TS_PhantomRouteHints_free(this_obj);
19585 // debug statements here
19587 // struct LDKCVec_ChannelDetailsZ PhantomRouteHints_get_channels(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
19589 export function PhantomRouteHints_get_channels(this_ptr: number): number {
19590 if(!isWasmInitialized) {
19591 throw new Error("initializeWasm() must be awaited first!");
19593 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_channels(this_ptr);
19594 return nativeResponseValue;
19596 // void PhantomRouteHints_set_channels(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKCVec_ChannelDetailsZ val);
19598 export function PhantomRouteHints_set_channels(this_ptr: number, val: number): void {
19599 if(!isWasmInitialized) {
19600 throw new Error("initializeWasm() must be awaited first!");
19602 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_channels(this_ptr, val);
19603 // debug statements here
19605 // uint64_t PhantomRouteHints_get_phantom_scid(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
19607 export function PhantomRouteHints_get_phantom_scid(this_ptr: number): bigint {
19608 if(!isWasmInitialized) {
19609 throw new Error("initializeWasm() must be awaited first!");
19611 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_phantom_scid(this_ptr);
19612 return nativeResponseValue;
19614 // void PhantomRouteHints_set_phantom_scid(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, uint64_t val);
19616 export function PhantomRouteHints_set_phantom_scid(this_ptr: number, val: bigint): void {
19617 if(!isWasmInitialized) {
19618 throw new Error("initializeWasm() must be awaited first!");
19620 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_phantom_scid(this_ptr, val);
19621 // debug statements here
19623 // struct LDKPublicKey PhantomRouteHints_get_real_node_pubkey(const struct LDKPhantomRouteHints *NONNULL_PTR this_ptr);
19625 export function PhantomRouteHints_get_real_node_pubkey(this_ptr: number): number {
19626 if(!isWasmInitialized) {
19627 throw new Error("initializeWasm() must be awaited first!");
19629 const nativeResponseValue = wasm.TS_PhantomRouteHints_get_real_node_pubkey(this_ptr);
19630 return nativeResponseValue;
19632 // void PhantomRouteHints_set_real_node_pubkey(struct LDKPhantomRouteHints *NONNULL_PTR this_ptr, struct LDKPublicKey val);
19634 export function PhantomRouteHints_set_real_node_pubkey(this_ptr: number, val: number): void {
19635 if(!isWasmInitialized) {
19636 throw new Error("initializeWasm() must be awaited first!");
19638 const nativeResponseValue = wasm.TS_PhantomRouteHints_set_real_node_pubkey(this_ptr, val);
19639 // debug statements here
19641 // MUST_USE_RES struct LDKPhantomRouteHints PhantomRouteHints_new(struct LDKCVec_ChannelDetailsZ channels_arg, uint64_t phantom_scid_arg, struct LDKPublicKey real_node_pubkey_arg);
19643 export function PhantomRouteHints_new(channels_arg: number, phantom_scid_arg: bigint, real_node_pubkey_arg: number): number {
19644 if(!isWasmInitialized) {
19645 throw new Error("initializeWasm() must be awaited first!");
19647 const nativeResponseValue = wasm.TS_PhantomRouteHints_new(channels_arg, phantom_scid_arg, real_node_pubkey_arg);
19648 return nativeResponseValue;
19650 // uintptr_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg);
19652 export function PhantomRouteHints_clone_ptr(arg: number): number {
19653 if(!isWasmInitialized) {
19654 throw new Error("initializeWasm() must be awaited first!");
19656 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone_ptr(arg);
19657 return nativeResponseValue;
19659 // struct LDKPhantomRouteHints PhantomRouteHints_clone(const struct LDKPhantomRouteHints *NONNULL_PTR orig);
19661 export function PhantomRouteHints_clone(orig: number): number {
19662 if(!isWasmInitialized) {
19663 throw new Error("initializeWasm() must be awaited first!");
19665 const nativeResponseValue = wasm.TS_PhantomRouteHints_clone(orig);
19666 return nativeResponseValue;
19668 // 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);
19670 export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number {
19671 if(!isWasmInitialized) {
19672 throw new Error("initializeWasm() must be awaited first!");
19674 const nativeResponseValue = wasm.TS_ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
19675 return nativeResponseValue;
19677 // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
19679 export function ChannelManager_get_current_default_configuration(this_arg: number): number {
19680 if(!isWasmInitialized) {
19681 throw new Error("initializeWasm() must be awaited first!");
19683 const nativeResponseValue = wasm.TS_ChannelManager_get_current_default_configuration(this_arg);
19684 return nativeResponseValue;
19686 // 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);
19688 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 {
19689 if(!isWasmInitialized) {
19690 throw new Error("initializeWasm() must be awaited first!");
19692 const nativeResponseValue = wasm.TS_ChannelManager_create_channel(this_arg, their_network_key, channel_value_satoshis, push_msat, user_channel_id, override_config);
19693 return nativeResponseValue;
19695 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
19697 export function ChannelManager_list_channels(this_arg: number): number {
19698 if(!isWasmInitialized) {
19699 throw new Error("initializeWasm() must be awaited first!");
19701 const nativeResponseValue = wasm.TS_ChannelManager_list_channels(this_arg);
19702 return nativeResponseValue;
19704 // MUST_USE_RES struct LDKCVec_ChannelDetailsZ ChannelManager_list_usable_channels(const struct LDKChannelManager *NONNULL_PTR this_arg);
19706 export function ChannelManager_list_usable_channels(this_arg: number): number {
19707 if(!isWasmInitialized) {
19708 throw new Error("initializeWasm() must be awaited first!");
19710 const nativeResponseValue = wasm.TS_ChannelManager_list_usable_channels(this_arg);
19711 return nativeResponseValue;
19713 // 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);
19715 export function ChannelManager_close_channel(this_arg: number, channel_id: number, counterparty_node_id: number): number {
19716 if(!isWasmInitialized) {
19717 throw new Error("initializeWasm() must be awaited first!");
19719 const nativeResponseValue = wasm.TS_ChannelManager_close_channel(this_arg, channel_id, counterparty_node_id);
19720 return nativeResponseValue;
19722 // 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);
19724 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 {
19725 if(!isWasmInitialized) {
19726 throw new Error("initializeWasm() must be awaited first!");
19728 const nativeResponseValue = wasm.TS_ChannelManager_close_channel_with_target_feerate(this_arg, channel_id, counterparty_node_id, target_feerate_sats_per_1000_weight);
19729 return nativeResponseValue;
19731 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
19733 export function ChannelManager_force_close_broadcasting_latest_txn(this_arg: number, channel_id: number, counterparty_node_id: number): number {
19734 if(!isWasmInitialized) {
19735 throw new Error("initializeWasm() must be awaited first!");
19737 const nativeResponseValue = wasm.TS_ChannelManager_force_close_broadcasting_latest_txn(this_arg, channel_id, counterparty_node_id);
19738 return nativeResponseValue;
19740 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_force_close_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*channel_id)[32], struct LDKPublicKey counterparty_node_id);
19742 export function ChannelManager_force_close_without_broadcasting_txn(this_arg: number, channel_id: number, counterparty_node_id: number): number {
19743 if(!isWasmInitialized) {
19744 throw new Error("initializeWasm() must be awaited first!");
19746 const nativeResponseValue = wasm.TS_ChannelManager_force_close_without_broadcasting_txn(this_arg, channel_id, counterparty_node_id);
19747 return nativeResponseValue;
19749 // void ChannelManager_force_close_all_channels_broadcasting_latest_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
19751 export function ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg: number): void {
19752 if(!isWasmInitialized) {
19753 throw new Error("initializeWasm() must be awaited first!");
19755 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(this_arg);
19756 // debug statements here
19758 // void ChannelManager_force_close_all_channels_without_broadcasting_txn(const struct LDKChannelManager *NONNULL_PTR this_arg);
19760 export function ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg: number): void {
19761 if(!isWasmInitialized) {
19762 throw new Error("initializeWasm() must be awaited first!");
19764 const nativeResponseValue = wasm.TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(this_arg);
19765 // debug statements here
19767 // 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);
19769 export function ChannelManager_send_payment(this_arg: number, route: number, payment_hash: number, payment_secret: number): number {
19770 if(!isWasmInitialized) {
19771 throw new Error("initializeWasm() must be awaited first!");
19773 const nativeResponseValue = wasm.TS_ChannelManager_send_payment(this_arg, route, payment_hash, payment_secret);
19774 return nativeResponseValue;
19776 // 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);
19778 export function ChannelManager_retry_payment(this_arg: number, route: number, payment_id: number): number {
19779 if(!isWasmInitialized) {
19780 throw new Error("initializeWasm() must be awaited first!");
19782 const nativeResponseValue = wasm.TS_ChannelManager_retry_payment(this_arg, route, payment_id);
19783 return nativeResponseValue;
19785 // void ChannelManager_abandon_payment(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_id);
19787 export function ChannelManager_abandon_payment(this_arg: number, payment_id: number): void {
19788 if(!isWasmInitialized) {
19789 throw new Error("initializeWasm() must be awaited first!");
19791 const nativeResponseValue = wasm.TS_ChannelManager_abandon_payment(this_arg, payment_id);
19792 // debug statements here
19794 // 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);
19796 export function ChannelManager_send_spontaneous_payment(this_arg: number, route: number, payment_preimage: number): number {
19797 if(!isWasmInitialized) {
19798 throw new Error("initializeWasm() must be awaited first!");
19800 const nativeResponseValue = wasm.TS_ChannelManager_send_spontaneous_payment(this_arg, route, payment_preimage);
19801 return nativeResponseValue;
19803 // 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);
19805 export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, funding_transaction: number): number {
19806 if(!isWasmInitialized) {
19807 throw new Error("initializeWasm() must be awaited first!");
19809 const nativeResponseValue = wasm.TS_ChannelManager_funding_transaction_generated(this_arg, temporary_channel_id, counterparty_node_id, funding_transaction);
19810 return nativeResponseValue;
19812 // void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
19814 export function ChannelManager_broadcast_node_announcement(this_arg: number, rgb: number, alias: number, addresses: number): void {
19815 if(!isWasmInitialized) {
19816 throw new Error("initializeWasm() must be awaited first!");
19818 const nativeResponseValue = wasm.TS_ChannelManager_broadcast_node_announcement(this_arg, rgb, alias, addresses);
19819 // debug statements here
19821 // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_update_channel_config(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey counterparty_node_id, struct LDKCVec_ThirtyTwoBytesZ channel_ids, const struct LDKChannelConfig *NONNULL_PTR config);
19823 export function ChannelManager_update_channel_config(this_arg: number, counterparty_node_id: number, channel_ids: number, config: number): number {
19824 if(!isWasmInitialized) {
19825 throw new Error("initializeWasm() must be awaited first!");
19827 const nativeResponseValue = wasm.TS_ChannelManager_update_channel_config(this_arg, counterparty_node_id, channel_ids, config);
19828 return nativeResponseValue;
19830 // void ChannelManager_process_pending_htlc_forwards(const struct LDKChannelManager *NONNULL_PTR this_arg);
19832 export function ChannelManager_process_pending_htlc_forwards(this_arg: number): void {
19833 if(!isWasmInitialized) {
19834 throw new Error("initializeWasm() must be awaited first!");
19836 const nativeResponseValue = wasm.TS_ChannelManager_process_pending_htlc_forwards(this_arg);
19837 // debug statements here
19839 // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
19841 export function ChannelManager_timer_tick_occurred(this_arg: number): void {
19842 if(!isWasmInitialized) {
19843 throw new Error("initializeWasm() must be awaited first!");
19845 const nativeResponseValue = wasm.TS_ChannelManager_timer_tick_occurred(this_arg);
19846 // debug statements here
19848 // void ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
19850 export function ChannelManager_fail_htlc_backwards(this_arg: number, payment_hash: number): void {
19851 if(!isWasmInitialized) {
19852 throw new Error("initializeWasm() must be awaited first!");
19854 const nativeResponseValue = wasm.TS_ChannelManager_fail_htlc_backwards(this_arg, payment_hash);
19855 // debug statements here
19857 // void ChannelManager_claim_funds(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThirtyTwoBytes payment_preimage);
19859 export function ChannelManager_claim_funds(this_arg: number, payment_preimage: number): void {
19860 if(!isWasmInitialized) {
19861 throw new Error("initializeWasm() must be awaited first!");
19863 const nativeResponseValue = wasm.TS_ChannelManager_claim_funds(this_arg, payment_preimage);
19864 // debug statements here
19866 // MUST_USE_RES struct LDKPublicKey ChannelManager_get_our_node_id(const struct LDKChannelManager *NONNULL_PTR this_arg);
19868 export function ChannelManager_get_our_node_id(this_arg: number): number {
19869 if(!isWasmInitialized) {
19870 throw new Error("initializeWasm() must be awaited first!");
19872 const nativeResponseValue = wasm.TS_ChannelManager_get_our_node_id(this_arg);
19873 return nativeResponseValue;
19875 // 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);
19877 export function ChannelManager_accept_inbound_channel(this_arg: number, temporary_channel_id: number, counterparty_node_id: number, user_channel_id: bigint): number {
19878 if(!isWasmInitialized) {
19879 throw new Error("initializeWasm() must be awaited first!");
19881 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
19882 return nativeResponseValue;
19884 // 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);
19886 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 {
19887 if(!isWasmInitialized) {
19888 throw new Error("initializeWasm() must be awaited first!");
19890 const nativeResponseValue = wasm.TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(this_arg, temporary_channel_id, counterparty_node_id, user_channel_id);
19891 return nativeResponseValue;
19893 // 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);
19895 export function ChannelManager_create_inbound_payment(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19896 if(!isWasmInitialized) {
19897 throw new Error("initializeWasm() must be awaited first!");
19899 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment(this_arg, min_value_msat, invoice_expiry_delta_secs);
19900 return nativeResponseValue;
19902 // 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);
19904 export function ChannelManager_create_inbound_payment_legacy(this_arg: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19905 if(!isWasmInitialized) {
19906 throw new Error("initializeWasm() must be awaited first!");
19908 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_legacy(this_arg, min_value_msat, invoice_expiry_delta_secs);
19909 return nativeResponseValue;
19911 // 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);
19913 export function ChannelManager_create_inbound_payment_for_hash(this_arg: number, payment_hash: number, min_value_msat: number, invoice_expiry_delta_secs: number): number {
19914 if(!isWasmInitialized) {
19915 throw new Error("initializeWasm() must be awaited first!");
19917 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
19918 return nativeResponseValue;
19920 // 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);
19922 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 {
19923 if(!isWasmInitialized) {
19924 throw new Error("initializeWasm() must be awaited first!");
19926 const nativeResponseValue = wasm.TS_ChannelManager_create_inbound_payment_for_hash_legacy(this_arg, payment_hash, min_value_msat, invoice_expiry_delta_secs);
19927 return nativeResponseValue;
19929 // 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);
19931 export function ChannelManager_get_payment_preimage(this_arg: number, payment_hash: number, payment_secret: number): number {
19932 if(!isWasmInitialized) {
19933 throw new Error("initializeWasm() must be awaited first!");
19935 const nativeResponseValue = wasm.TS_ChannelManager_get_payment_preimage(this_arg, payment_hash, payment_secret);
19936 return nativeResponseValue;
19938 // MUST_USE_RES uint64_t ChannelManager_get_phantom_scid(const struct LDKChannelManager *NONNULL_PTR this_arg);
19940 export function ChannelManager_get_phantom_scid(this_arg: number): bigint {
19941 if(!isWasmInitialized) {
19942 throw new Error("initializeWasm() must be awaited first!");
19944 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_scid(this_arg);
19945 return nativeResponseValue;
19947 // MUST_USE_RES struct LDKPhantomRouteHints ChannelManager_get_phantom_route_hints(const struct LDKChannelManager *NONNULL_PTR this_arg);
19949 export function ChannelManager_get_phantom_route_hints(this_arg: number): number {
19950 if(!isWasmInitialized) {
19951 throw new Error("initializeWasm() must be awaited first!");
19953 const nativeResponseValue = wasm.TS_ChannelManager_get_phantom_route_hints(this_arg);
19954 return nativeResponseValue;
19956 // struct LDKMessageSendEventsProvider ChannelManager_as_MessageSendEventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
19958 export function ChannelManager_as_MessageSendEventsProvider(this_arg: number): number {
19959 if(!isWasmInitialized) {
19960 throw new Error("initializeWasm() must be awaited first!");
19962 const nativeResponseValue = wasm.TS_ChannelManager_as_MessageSendEventsProvider(this_arg);
19963 return nativeResponseValue;
19965 // struct LDKEventsProvider ChannelManager_as_EventsProvider(const struct LDKChannelManager *NONNULL_PTR this_arg);
19967 export function ChannelManager_as_EventsProvider(this_arg: number): number {
19968 if(!isWasmInitialized) {
19969 throw new Error("initializeWasm() must be awaited first!");
19971 const nativeResponseValue = wasm.TS_ChannelManager_as_EventsProvider(this_arg);
19972 return nativeResponseValue;
19974 // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg);
19976 export function ChannelManager_as_Listen(this_arg: number): number {
19977 if(!isWasmInitialized) {
19978 throw new Error("initializeWasm() must be awaited first!");
19980 const nativeResponseValue = wasm.TS_ChannelManager_as_Listen(this_arg);
19981 return nativeResponseValue;
19983 // struct LDKConfirm ChannelManager_as_Confirm(const struct LDKChannelManager *NONNULL_PTR this_arg);
19985 export function ChannelManager_as_Confirm(this_arg: number): number {
19986 if(!isWasmInitialized) {
19987 throw new Error("initializeWasm() must be awaited first!");
19989 const nativeResponseValue = wasm.TS_ChannelManager_as_Confirm(this_arg);
19990 return nativeResponseValue;
19992 // void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
19994 export function ChannelManager_await_persistable_update(this_arg: number): void {
19995 if(!isWasmInitialized) {
19996 throw new Error("initializeWasm() must be awaited first!");
19998 const nativeResponseValue = wasm.TS_ChannelManager_await_persistable_update(this_arg);
19999 // debug statements here
20001 // MUST_USE_RES struct LDKBestBlock ChannelManager_current_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg);
20003 export function ChannelManager_current_best_block(this_arg: number): number {
20004 if(!isWasmInitialized) {
20005 throw new Error("initializeWasm() must be awaited first!");
20007 const nativeResponseValue = wasm.TS_ChannelManager_current_best_block(this_arg);
20008 return nativeResponseValue;
20010 // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg);
20012 export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number {
20013 if(!isWasmInitialized) {
20014 throw new Error("initializeWasm() must be awaited first!");
20016 const nativeResponseValue = wasm.TS_ChannelManager_as_ChannelMessageHandler(this_arg);
20017 return nativeResponseValue;
20019 // struct LDKCVec_u8Z CounterpartyForwardingInfo_write(const struct LDKCounterpartyForwardingInfo *NONNULL_PTR obj);
20021 export function CounterpartyForwardingInfo_write(obj: number): number {
20022 if(!isWasmInitialized) {
20023 throw new Error("initializeWasm() must be awaited first!");
20025 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_write(obj);
20026 return nativeResponseValue;
20028 // struct LDKCResult_CounterpartyForwardingInfoDecodeErrorZ CounterpartyForwardingInfo_read(struct LDKu8slice ser);
20030 export function CounterpartyForwardingInfo_read(ser: number): number {
20031 if(!isWasmInitialized) {
20032 throw new Error("initializeWasm() must be awaited first!");
20034 const nativeResponseValue = wasm.TS_CounterpartyForwardingInfo_read(ser);
20035 return nativeResponseValue;
20037 // struct LDKCVec_u8Z ChannelCounterparty_write(const struct LDKChannelCounterparty *NONNULL_PTR obj);
20039 export function ChannelCounterparty_write(obj: number): number {
20040 if(!isWasmInitialized) {
20041 throw new Error("initializeWasm() must be awaited first!");
20043 const nativeResponseValue = wasm.TS_ChannelCounterparty_write(obj);
20044 return nativeResponseValue;
20046 // struct LDKCResult_ChannelCounterpartyDecodeErrorZ ChannelCounterparty_read(struct LDKu8slice ser);
20048 export function ChannelCounterparty_read(ser: number): number {
20049 if(!isWasmInitialized) {
20050 throw new Error("initializeWasm() must be awaited first!");
20052 const nativeResponseValue = wasm.TS_ChannelCounterparty_read(ser);
20053 return nativeResponseValue;
20055 // struct LDKCVec_u8Z ChannelDetails_write(const struct LDKChannelDetails *NONNULL_PTR obj);
20057 export function ChannelDetails_write(obj: number): number {
20058 if(!isWasmInitialized) {
20059 throw new Error("initializeWasm() must be awaited first!");
20061 const nativeResponseValue = wasm.TS_ChannelDetails_write(obj);
20062 return nativeResponseValue;
20064 // struct LDKCResult_ChannelDetailsDecodeErrorZ ChannelDetails_read(struct LDKu8slice ser);
20066 export function ChannelDetails_read(ser: number): number {
20067 if(!isWasmInitialized) {
20068 throw new Error("initializeWasm() must be awaited first!");
20070 const nativeResponseValue = wasm.TS_ChannelDetails_read(ser);
20071 return nativeResponseValue;
20073 // struct LDKCVec_u8Z PhantomRouteHints_write(const struct LDKPhantomRouteHints *NONNULL_PTR obj);
20075 export function PhantomRouteHints_write(obj: number): number {
20076 if(!isWasmInitialized) {
20077 throw new Error("initializeWasm() must be awaited first!");
20079 const nativeResponseValue = wasm.TS_PhantomRouteHints_write(obj);
20080 return nativeResponseValue;
20082 // struct LDKCResult_PhantomRouteHintsDecodeErrorZ PhantomRouteHints_read(struct LDKu8slice ser);
20084 export function PhantomRouteHints_read(ser: number): number {
20085 if(!isWasmInitialized) {
20086 throw new Error("initializeWasm() must be awaited first!");
20088 const nativeResponseValue = wasm.TS_PhantomRouteHints_read(ser);
20089 return nativeResponseValue;
20091 // struct LDKCVec_u8Z ChannelManager_write(const struct LDKChannelManager *NONNULL_PTR obj);
20093 export function ChannelManager_write(obj: number): number {
20094 if(!isWasmInitialized) {
20095 throw new Error("initializeWasm() must be awaited first!");
20097 const nativeResponseValue = wasm.TS_ChannelManager_write(obj);
20098 return nativeResponseValue;
20100 // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
20102 export function ChannelManagerReadArgs_free(this_obj: number): void {
20103 if(!isWasmInitialized) {
20104 throw new Error("initializeWasm() must be awaited first!");
20106 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_free(this_obj);
20107 // debug statements here
20109 // const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20111 export function ChannelManagerReadArgs_get_keys_manager(this_ptr: number): number {
20112 if(!isWasmInitialized) {
20113 throw new Error("initializeWasm() must be awaited first!");
20115 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_keys_manager(this_ptr);
20116 return nativeResponseValue;
20118 // void ChannelManagerReadArgs_set_keys_manager(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKKeysInterface val);
20120 export function ChannelManagerReadArgs_set_keys_manager(this_ptr: number, val: number): void {
20121 if(!isWasmInitialized) {
20122 throw new Error("initializeWasm() must be awaited first!");
20124 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_keys_manager(this_ptr, val);
20125 // debug statements here
20127 // const struct LDKFeeEstimator *ChannelManagerReadArgs_get_fee_estimator(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20129 export function ChannelManagerReadArgs_get_fee_estimator(this_ptr: number): number {
20130 if(!isWasmInitialized) {
20131 throw new Error("initializeWasm() must be awaited first!");
20133 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_fee_estimator(this_ptr);
20134 return nativeResponseValue;
20136 // void ChannelManagerReadArgs_set_fee_estimator(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKFeeEstimator val);
20138 export function ChannelManagerReadArgs_set_fee_estimator(this_ptr: number, val: number): void {
20139 if(!isWasmInitialized) {
20140 throw new Error("initializeWasm() must be awaited first!");
20142 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_fee_estimator(this_ptr, val);
20143 // debug statements here
20145 // const struct LDKWatch *ChannelManagerReadArgs_get_chain_monitor(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20147 export function ChannelManagerReadArgs_get_chain_monitor(this_ptr: number): number {
20148 if(!isWasmInitialized) {
20149 throw new Error("initializeWasm() must be awaited first!");
20151 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_chain_monitor(this_ptr);
20152 return nativeResponseValue;
20154 // void ChannelManagerReadArgs_set_chain_monitor(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKWatch val);
20156 export function ChannelManagerReadArgs_set_chain_monitor(this_ptr: number, val: number): void {
20157 if(!isWasmInitialized) {
20158 throw new Error("initializeWasm() must be awaited first!");
20160 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_chain_monitor(this_ptr, val);
20161 // debug statements here
20163 // const struct LDKBroadcasterInterface *ChannelManagerReadArgs_get_tx_broadcaster(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20165 export function ChannelManagerReadArgs_get_tx_broadcaster(this_ptr: number): number {
20166 if(!isWasmInitialized) {
20167 throw new Error("initializeWasm() must be awaited first!");
20169 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_tx_broadcaster(this_ptr);
20170 return nativeResponseValue;
20172 // void ChannelManagerReadArgs_set_tx_broadcaster(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKBroadcasterInterface val);
20174 export function ChannelManagerReadArgs_set_tx_broadcaster(this_ptr: number, val: number): void {
20175 if(!isWasmInitialized) {
20176 throw new Error("initializeWasm() must be awaited first!");
20178 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_tx_broadcaster(this_ptr, val);
20179 // debug statements here
20181 // const struct LDKLogger *ChannelManagerReadArgs_get_logger(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20183 export function ChannelManagerReadArgs_get_logger(this_ptr: number): number {
20184 if(!isWasmInitialized) {
20185 throw new Error("initializeWasm() must be awaited first!");
20187 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_logger(this_ptr);
20188 return nativeResponseValue;
20190 // void ChannelManagerReadArgs_set_logger(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKLogger val);
20192 export function ChannelManagerReadArgs_set_logger(this_ptr: number, val: number): void {
20193 if(!isWasmInitialized) {
20194 throw new Error("initializeWasm() must be awaited first!");
20196 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_logger(this_ptr, val);
20197 // debug statements here
20199 // struct LDKUserConfig ChannelManagerReadArgs_get_default_config(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
20201 export function ChannelManagerReadArgs_get_default_config(this_ptr: number): number {
20202 if(!isWasmInitialized) {
20203 throw new Error("initializeWasm() must be awaited first!");
20205 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_get_default_config(this_ptr);
20206 return nativeResponseValue;
20208 // void ChannelManagerReadArgs_set_default_config(struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr, struct LDKUserConfig val);
20210 export function ChannelManagerReadArgs_set_default_config(this_ptr: number, val: number): void {
20211 if(!isWasmInitialized) {
20212 throw new Error("initializeWasm() must be awaited first!");
20214 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_set_default_config(this_ptr, val);
20215 // debug statements here
20217 // 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);
20219 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 {
20220 if(!isWasmInitialized) {
20221 throw new Error("initializeWasm() must be awaited first!");
20223 const nativeResponseValue = wasm.TS_ChannelManagerReadArgs_new(keys_manager, fee_estimator, chain_monitor, tx_broadcaster, logger, default_config, channel_monitors);
20224 return nativeResponseValue;
20226 // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ C2Tuple_BlockHashChannelManagerZ_read(struct LDKu8slice ser, struct LDKChannelManagerReadArgs arg);
20228 export function C2Tuple_BlockHashChannelManagerZ_read(ser: number, arg: number): number {
20229 if(!isWasmInitialized) {
20230 throw new Error("initializeWasm() must be awaited first!");
20232 const nativeResponseValue = wasm.TS_C2Tuple_BlockHashChannelManagerZ_read(ser, arg);
20233 return nativeResponseValue;
20235 // void ExpandedKey_free(struct LDKExpandedKey this_obj);
20237 export function ExpandedKey_free(this_obj: number): void {
20238 if(!isWasmInitialized) {
20239 throw new Error("initializeWasm() must be awaited first!");
20241 const nativeResponseValue = wasm.TS_ExpandedKey_free(this_obj);
20242 // debug statements here
20244 // MUST_USE_RES struct LDKExpandedKey ExpandedKey_new(const uint8_t (*key_material)[32]);
20246 export function ExpandedKey_new(key_material: number): number {
20247 if(!isWasmInitialized) {
20248 throw new Error("initializeWasm() must be awaited first!");
20250 const nativeResponseValue = wasm.TS_ExpandedKey_new(key_material);
20251 return nativeResponseValue;
20253 // 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);
20255 export function create(keys: number, min_value_msat: number, invoice_expiry_delta_secs: number, keys_manager: number, current_time: bigint): number {
20256 if(!isWasmInitialized) {
20257 throw new Error("initializeWasm() must be awaited first!");
20259 const nativeResponseValue = wasm.TS_create(keys, min_value_msat, invoice_expiry_delta_secs, keys_manager, current_time);
20260 return nativeResponseValue;
20262 // 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);
20264 export function create_from_hash(keys: number, min_value_msat: number, payment_hash: number, invoice_expiry_delta_secs: number, current_time: bigint): number {
20265 if(!isWasmInitialized) {
20266 throw new Error("initializeWasm() must be awaited first!");
20268 const nativeResponseValue = wasm.TS_create_from_hash(keys, min_value_msat, payment_hash, invoice_expiry_delta_secs, current_time);
20269 return nativeResponseValue;
20271 // void DecodeError_free(struct LDKDecodeError this_obj);
20273 export function DecodeError_free(this_obj: number): void {
20274 if(!isWasmInitialized) {
20275 throw new Error("initializeWasm() must be awaited first!");
20277 const nativeResponseValue = wasm.TS_DecodeError_free(this_obj);
20278 // debug statements here
20280 // uintptr_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg);
20282 export function DecodeError_clone_ptr(arg: number): number {
20283 if(!isWasmInitialized) {
20284 throw new Error("initializeWasm() must be awaited first!");
20286 const nativeResponseValue = wasm.TS_DecodeError_clone_ptr(arg);
20287 return nativeResponseValue;
20289 // struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
20291 export function DecodeError_clone(orig: number): number {
20292 if(!isWasmInitialized) {
20293 throw new Error("initializeWasm() must be awaited first!");
20295 const nativeResponseValue = wasm.TS_DecodeError_clone(orig);
20296 return nativeResponseValue;
20298 // void Init_free(struct LDKInit this_obj);
20300 export function Init_free(this_obj: number): void {
20301 if(!isWasmInitialized) {
20302 throw new Error("initializeWasm() must be awaited first!");
20304 const nativeResponseValue = wasm.TS_Init_free(this_obj);
20305 // debug statements here
20307 // struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
20309 export function Init_get_features(this_ptr: number): number {
20310 if(!isWasmInitialized) {
20311 throw new Error("initializeWasm() must be awaited first!");
20313 const nativeResponseValue = wasm.TS_Init_get_features(this_ptr);
20314 return nativeResponseValue;
20316 // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val);
20318 export function Init_set_features(this_ptr: number, val: number): void {
20319 if(!isWasmInitialized) {
20320 throw new Error("initializeWasm() must be awaited first!");
20322 const nativeResponseValue = wasm.TS_Init_set_features(this_ptr, val);
20323 // debug statements here
20325 // struct LDKCOption_NetAddressZ Init_get_remote_network_address(const struct LDKInit *NONNULL_PTR this_ptr);
20327 export function Init_get_remote_network_address(this_ptr: number): number {
20328 if(!isWasmInitialized) {
20329 throw new Error("initializeWasm() must be awaited first!");
20331 const nativeResponseValue = wasm.TS_Init_get_remote_network_address(this_ptr);
20332 return nativeResponseValue;
20334 // void Init_set_remote_network_address(struct LDKInit *NONNULL_PTR this_ptr, struct LDKCOption_NetAddressZ val);
20336 export function Init_set_remote_network_address(this_ptr: number, val: number): void {
20337 if(!isWasmInitialized) {
20338 throw new Error("initializeWasm() must be awaited first!");
20340 const nativeResponseValue = wasm.TS_Init_set_remote_network_address(this_ptr, val);
20341 // debug statements here
20343 // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg, struct LDKCOption_NetAddressZ remote_network_address_arg);
20345 export function Init_new(features_arg: number, remote_network_address_arg: number): number {
20346 if(!isWasmInitialized) {
20347 throw new Error("initializeWasm() must be awaited first!");
20349 const nativeResponseValue = wasm.TS_Init_new(features_arg, remote_network_address_arg);
20350 return nativeResponseValue;
20352 // uintptr_t Init_clone_ptr(LDKInit *NONNULL_PTR arg);
20354 export function Init_clone_ptr(arg: number): number {
20355 if(!isWasmInitialized) {
20356 throw new Error("initializeWasm() must be awaited first!");
20358 const nativeResponseValue = wasm.TS_Init_clone_ptr(arg);
20359 return nativeResponseValue;
20361 // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig);
20363 export function Init_clone(orig: number): number {
20364 if(!isWasmInitialized) {
20365 throw new Error("initializeWasm() must be awaited first!");
20367 const nativeResponseValue = wasm.TS_Init_clone(orig);
20368 return nativeResponseValue;
20370 // void ErrorMessage_free(struct LDKErrorMessage this_obj);
20372 export function ErrorMessage_free(this_obj: number): void {
20373 if(!isWasmInitialized) {
20374 throw new Error("initializeWasm() must be awaited first!");
20376 const nativeResponseValue = wasm.TS_ErrorMessage_free(this_obj);
20377 // debug statements here
20379 // const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
20381 export function ErrorMessage_get_channel_id(this_ptr: number): number {
20382 if(!isWasmInitialized) {
20383 throw new Error("initializeWasm() must be awaited first!");
20385 const nativeResponseValue = wasm.TS_ErrorMessage_get_channel_id(this_ptr);
20386 return nativeResponseValue;
20388 // void ErrorMessage_set_channel_id(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20390 export function ErrorMessage_set_channel_id(this_ptr: number, val: number): void {
20391 if(!isWasmInitialized) {
20392 throw new Error("initializeWasm() must be awaited first!");
20394 const nativeResponseValue = wasm.TS_ErrorMessage_set_channel_id(this_ptr, val);
20395 // debug statements here
20397 // struct LDKStr ErrorMessage_get_data(const struct LDKErrorMessage *NONNULL_PTR this_ptr);
20399 export function ErrorMessage_get_data(this_ptr: number): number {
20400 if(!isWasmInitialized) {
20401 throw new Error("initializeWasm() must be awaited first!");
20403 const nativeResponseValue = wasm.TS_ErrorMessage_get_data(this_ptr);
20404 return nativeResponseValue;
20406 // void ErrorMessage_set_data(struct LDKErrorMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20408 export function ErrorMessage_set_data(this_ptr: number, val: number): void {
20409 if(!isWasmInitialized) {
20410 throw new Error("initializeWasm() must be awaited first!");
20412 const nativeResponseValue = wasm.TS_ErrorMessage_set_data(this_ptr, val);
20413 // debug statements here
20415 // MUST_USE_RES struct LDKErrorMessage ErrorMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
20417 export function ErrorMessage_new(channel_id_arg: number, data_arg: number): number {
20418 if(!isWasmInitialized) {
20419 throw new Error("initializeWasm() must be awaited first!");
20421 const nativeResponseValue = wasm.TS_ErrorMessage_new(channel_id_arg, data_arg);
20422 return nativeResponseValue;
20424 // uintptr_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg);
20426 export function ErrorMessage_clone_ptr(arg: number): number {
20427 if(!isWasmInitialized) {
20428 throw new Error("initializeWasm() must be awaited first!");
20430 const nativeResponseValue = wasm.TS_ErrorMessage_clone_ptr(arg);
20431 return nativeResponseValue;
20433 // struct LDKErrorMessage ErrorMessage_clone(const struct LDKErrorMessage *NONNULL_PTR orig);
20435 export function ErrorMessage_clone(orig: number): number {
20436 if(!isWasmInitialized) {
20437 throw new Error("initializeWasm() must be awaited first!");
20439 const nativeResponseValue = wasm.TS_ErrorMessage_clone(orig);
20440 return nativeResponseValue;
20442 // void WarningMessage_free(struct LDKWarningMessage this_obj);
20444 export function WarningMessage_free(this_obj: number): void {
20445 if(!isWasmInitialized) {
20446 throw new Error("initializeWasm() must be awaited first!");
20448 const nativeResponseValue = wasm.TS_WarningMessage_free(this_obj);
20449 // debug statements here
20451 // const uint8_t (*WarningMessage_get_channel_id(const struct LDKWarningMessage *NONNULL_PTR this_ptr))[32];
20453 export function WarningMessage_get_channel_id(this_ptr: number): number {
20454 if(!isWasmInitialized) {
20455 throw new Error("initializeWasm() must be awaited first!");
20457 const nativeResponseValue = wasm.TS_WarningMessage_get_channel_id(this_ptr);
20458 return nativeResponseValue;
20460 // void WarningMessage_set_channel_id(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20462 export function WarningMessage_set_channel_id(this_ptr: number, val: number): void {
20463 if(!isWasmInitialized) {
20464 throw new Error("initializeWasm() must be awaited first!");
20466 const nativeResponseValue = wasm.TS_WarningMessage_set_channel_id(this_ptr, val);
20467 // debug statements here
20469 // struct LDKStr WarningMessage_get_data(const struct LDKWarningMessage *NONNULL_PTR this_ptr);
20471 export function WarningMessage_get_data(this_ptr: number): number {
20472 if(!isWasmInitialized) {
20473 throw new Error("initializeWasm() must be awaited first!");
20475 const nativeResponseValue = wasm.TS_WarningMessage_get_data(this_ptr);
20476 return nativeResponseValue;
20478 // void WarningMessage_set_data(struct LDKWarningMessage *NONNULL_PTR this_ptr, struct LDKStr val);
20480 export function WarningMessage_set_data(this_ptr: number, val: number): void {
20481 if(!isWasmInitialized) {
20482 throw new Error("initializeWasm() must be awaited first!");
20484 const nativeResponseValue = wasm.TS_WarningMessage_set_data(this_ptr, val);
20485 // debug statements here
20487 // MUST_USE_RES struct LDKWarningMessage WarningMessage_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKStr data_arg);
20489 export function WarningMessage_new(channel_id_arg: number, data_arg: number): number {
20490 if(!isWasmInitialized) {
20491 throw new Error("initializeWasm() must be awaited first!");
20493 const nativeResponseValue = wasm.TS_WarningMessage_new(channel_id_arg, data_arg);
20494 return nativeResponseValue;
20496 // uintptr_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg);
20498 export function WarningMessage_clone_ptr(arg: number): number {
20499 if(!isWasmInitialized) {
20500 throw new Error("initializeWasm() must be awaited first!");
20502 const nativeResponseValue = wasm.TS_WarningMessage_clone_ptr(arg);
20503 return nativeResponseValue;
20505 // struct LDKWarningMessage WarningMessage_clone(const struct LDKWarningMessage *NONNULL_PTR orig);
20507 export function WarningMessage_clone(orig: number): number {
20508 if(!isWasmInitialized) {
20509 throw new Error("initializeWasm() must be awaited first!");
20511 const nativeResponseValue = wasm.TS_WarningMessage_clone(orig);
20512 return nativeResponseValue;
20514 // void Ping_free(struct LDKPing this_obj);
20516 export function Ping_free(this_obj: number): void {
20517 if(!isWasmInitialized) {
20518 throw new Error("initializeWasm() must be awaited first!");
20520 const nativeResponseValue = wasm.TS_Ping_free(this_obj);
20521 // debug statements here
20523 // uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
20525 export function Ping_get_ponglen(this_ptr: number): number {
20526 if(!isWasmInitialized) {
20527 throw new Error("initializeWasm() must be awaited first!");
20529 const nativeResponseValue = wasm.TS_Ping_get_ponglen(this_ptr);
20530 return nativeResponseValue;
20532 // void Ping_set_ponglen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
20534 export function Ping_set_ponglen(this_ptr: number, val: number): void {
20535 if(!isWasmInitialized) {
20536 throw new Error("initializeWasm() must be awaited first!");
20538 const nativeResponseValue = wasm.TS_Ping_set_ponglen(this_ptr, val);
20539 // debug statements here
20541 // uint16_t Ping_get_byteslen(const struct LDKPing *NONNULL_PTR this_ptr);
20543 export function Ping_get_byteslen(this_ptr: number): number {
20544 if(!isWasmInitialized) {
20545 throw new Error("initializeWasm() must be awaited first!");
20547 const nativeResponseValue = wasm.TS_Ping_get_byteslen(this_ptr);
20548 return nativeResponseValue;
20550 // void Ping_set_byteslen(struct LDKPing *NONNULL_PTR this_ptr, uint16_t val);
20552 export function Ping_set_byteslen(this_ptr: number, val: number): void {
20553 if(!isWasmInitialized) {
20554 throw new Error("initializeWasm() must be awaited first!");
20556 const nativeResponseValue = wasm.TS_Ping_set_byteslen(this_ptr, val);
20557 // debug statements here
20559 // MUST_USE_RES struct LDKPing Ping_new(uint16_t ponglen_arg, uint16_t byteslen_arg);
20561 export function Ping_new(ponglen_arg: number, byteslen_arg: number): number {
20562 if(!isWasmInitialized) {
20563 throw new Error("initializeWasm() must be awaited first!");
20565 const nativeResponseValue = wasm.TS_Ping_new(ponglen_arg, byteslen_arg);
20566 return nativeResponseValue;
20568 // uintptr_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg);
20570 export function Ping_clone_ptr(arg: number): number {
20571 if(!isWasmInitialized) {
20572 throw new Error("initializeWasm() must be awaited first!");
20574 const nativeResponseValue = wasm.TS_Ping_clone_ptr(arg);
20575 return nativeResponseValue;
20577 // struct LDKPing Ping_clone(const struct LDKPing *NONNULL_PTR orig);
20579 export function Ping_clone(orig: number): number {
20580 if(!isWasmInitialized) {
20581 throw new Error("initializeWasm() must be awaited first!");
20583 const nativeResponseValue = wasm.TS_Ping_clone(orig);
20584 return nativeResponseValue;
20586 // void Pong_free(struct LDKPong this_obj);
20588 export function Pong_free(this_obj: number): void {
20589 if(!isWasmInitialized) {
20590 throw new Error("initializeWasm() must be awaited first!");
20592 const nativeResponseValue = wasm.TS_Pong_free(this_obj);
20593 // debug statements here
20595 // uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
20597 export function Pong_get_byteslen(this_ptr: number): number {
20598 if(!isWasmInitialized) {
20599 throw new Error("initializeWasm() must be awaited first!");
20601 const nativeResponseValue = wasm.TS_Pong_get_byteslen(this_ptr);
20602 return nativeResponseValue;
20604 // void Pong_set_byteslen(struct LDKPong *NONNULL_PTR this_ptr, uint16_t val);
20606 export function Pong_set_byteslen(this_ptr: number, val: number): void {
20607 if(!isWasmInitialized) {
20608 throw new Error("initializeWasm() must be awaited first!");
20610 const nativeResponseValue = wasm.TS_Pong_set_byteslen(this_ptr, val);
20611 // debug statements here
20613 // MUST_USE_RES struct LDKPong Pong_new(uint16_t byteslen_arg);
20615 export function Pong_new(byteslen_arg: number): number {
20616 if(!isWasmInitialized) {
20617 throw new Error("initializeWasm() must be awaited first!");
20619 const nativeResponseValue = wasm.TS_Pong_new(byteslen_arg);
20620 return nativeResponseValue;
20622 // uintptr_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg);
20624 export function Pong_clone_ptr(arg: number): number {
20625 if(!isWasmInitialized) {
20626 throw new Error("initializeWasm() must be awaited first!");
20628 const nativeResponseValue = wasm.TS_Pong_clone_ptr(arg);
20629 return nativeResponseValue;
20631 // struct LDKPong Pong_clone(const struct LDKPong *NONNULL_PTR orig);
20633 export function Pong_clone(orig: number): number {
20634 if(!isWasmInitialized) {
20635 throw new Error("initializeWasm() must be awaited first!");
20637 const nativeResponseValue = wasm.TS_Pong_clone(orig);
20638 return nativeResponseValue;
20640 // void OpenChannel_free(struct LDKOpenChannel this_obj);
20642 export function OpenChannel_free(this_obj: number): void {
20643 if(!isWasmInitialized) {
20644 throw new Error("initializeWasm() must be awaited first!");
20646 const nativeResponseValue = wasm.TS_OpenChannel_free(this_obj);
20647 // debug statements here
20649 // const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
20651 export function OpenChannel_get_chain_hash(this_ptr: number): number {
20652 if(!isWasmInitialized) {
20653 throw new Error("initializeWasm() must be awaited first!");
20655 const nativeResponseValue = wasm.TS_OpenChannel_get_chain_hash(this_ptr);
20656 return nativeResponseValue;
20658 // void OpenChannel_set_chain_hash(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20660 export function OpenChannel_set_chain_hash(this_ptr: number, val: number): void {
20661 if(!isWasmInitialized) {
20662 throw new Error("initializeWasm() must be awaited first!");
20664 const nativeResponseValue = wasm.TS_OpenChannel_set_chain_hash(this_ptr, val);
20665 // debug statements here
20667 // const uint8_t (*OpenChannel_get_temporary_channel_id(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
20669 export function OpenChannel_get_temporary_channel_id(this_ptr: number): number {
20670 if(!isWasmInitialized) {
20671 throw new Error("initializeWasm() must be awaited first!");
20673 const nativeResponseValue = wasm.TS_OpenChannel_get_temporary_channel_id(this_ptr);
20674 return nativeResponseValue;
20676 // void OpenChannel_set_temporary_channel_id(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
20678 export function OpenChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
20679 if(!isWasmInitialized) {
20680 throw new Error("initializeWasm() must be awaited first!");
20682 const nativeResponseValue = wasm.TS_OpenChannel_set_temporary_channel_id(this_ptr, val);
20683 // debug statements here
20685 // uint64_t OpenChannel_get_funding_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20687 export function OpenChannel_get_funding_satoshis(this_ptr: number): bigint {
20688 if(!isWasmInitialized) {
20689 throw new Error("initializeWasm() must be awaited first!");
20691 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_satoshis(this_ptr);
20692 return nativeResponseValue;
20694 // void OpenChannel_set_funding_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20696 export function OpenChannel_set_funding_satoshis(this_ptr: number, val: bigint): void {
20697 if(!isWasmInitialized) {
20698 throw new Error("initializeWasm() must be awaited first!");
20700 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_satoshis(this_ptr, val);
20701 // debug statements here
20703 // uint64_t OpenChannel_get_push_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20705 export function OpenChannel_get_push_msat(this_ptr: number): bigint {
20706 if(!isWasmInitialized) {
20707 throw new Error("initializeWasm() must be awaited first!");
20709 const nativeResponseValue = wasm.TS_OpenChannel_get_push_msat(this_ptr);
20710 return nativeResponseValue;
20712 // void OpenChannel_set_push_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20714 export function OpenChannel_set_push_msat(this_ptr: number, val: bigint): void {
20715 if(!isWasmInitialized) {
20716 throw new Error("initializeWasm() must be awaited first!");
20718 const nativeResponseValue = wasm.TS_OpenChannel_set_push_msat(this_ptr, val);
20719 // debug statements here
20721 // uint64_t OpenChannel_get_dust_limit_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20723 export function OpenChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
20724 if(!isWasmInitialized) {
20725 throw new Error("initializeWasm() must be awaited first!");
20727 const nativeResponseValue = wasm.TS_OpenChannel_get_dust_limit_satoshis(this_ptr);
20728 return nativeResponseValue;
20730 // void OpenChannel_set_dust_limit_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20732 export function OpenChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
20733 if(!isWasmInitialized) {
20734 throw new Error("initializeWasm() must be awaited first!");
20736 const nativeResponseValue = wasm.TS_OpenChannel_set_dust_limit_satoshis(this_ptr, val);
20737 // debug statements here
20739 // uint64_t OpenChannel_get_max_htlc_value_in_flight_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20741 export function OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
20742 if(!isWasmInitialized) {
20743 throw new Error("initializeWasm() must be awaited first!");
20745 const nativeResponseValue = wasm.TS_OpenChannel_get_max_htlc_value_in_flight_msat(this_ptr);
20746 return nativeResponseValue;
20748 // void OpenChannel_set_max_htlc_value_in_flight_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20750 export function OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
20751 if(!isWasmInitialized) {
20752 throw new Error("initializeWasm() must be awaited first!");
20754 const nativeResponseValue = wasm.TS_OpenChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
20755 // debug statements here
20757 // uint64_t OpenChannel_get_channel_reserve_satoshis(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20759 export function OpenChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
20760 if(!isWasmInitialized) {
20761 throw new Error("initializeWasm() must be awaited first!");
20763 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_reserve_satoshis(this_ptr);
20764 return nativeResponseValue;
20766 // void OpenChannel_set_channel_reserve_satoshis(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20768 export function OpenChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
20769 if(!isWasmInitialized) {
20770 throw new Error("initializeWasm() must be awaited first!");
20772 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_reserve_satoshis(this_ptr, val);
20773 // debug statements here
20775 // uint64_t OpenChannel_get_htlc_minimum_msat(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20777 export function OpenChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
20778 if(!isWasmInitialized) {
20779 throw new Error("initializeWasm() must be awaited first!");
20781 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_minimum_msat(this_ptr);
20782 return nativeResponseValue;
20784 // void OpenChannel_set_htlc_minimum_msat(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint64_t val);
20786 export function OpenChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
20787 if(!isWasmInitialized) {
20788 throw new Error("initializeWasm() must be awaited first!");
20790 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_minimum_msat(this_ptr, val);
20791 // debug statements here
20793 // uint32_t OpenChannel_get_feerate_per_kw(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20795 export function OpenChannel_get_feerate_per_kw(this_ptr: number): number {
20796 if(!isWasmInitialized) {
20797 throw new Error("initializeWasm() must be awaited first!");
20799 const nativeResponseValue = wasm.TS_OpenChannel_get_feerate_per_kw(this_ptr);
20800 return nativeResponseValue;
20802 // void OpenChannel_set_feerate_per_kw(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint32_t val);
20804 export function OpenChannel_set_feerate_per_kw(this_ptr: number, val: number): void {
20805 if(!isWasmInitialized) {
20806 throw new Error("initializeWasm() must be awaited first!");
20808 const nativeResponseValue = wasm.TS_OpenChannel_set_feerate_per_kw(this_ptr, val);
20809 // debug statements here
20811 // uint16_t OpenChannel_get_to_self_delay(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20813 export function OpenChannel_get_to_self_delay(this_ptr: number): number {
20814 if(!isWasmInitialized) {
20815 throw new Error("initializeWasm() must be awaited first!");
20817 const nativeResponseValue = wasm.TS_OpenChannel_get_to_self_delay(this_ptr);
20818 return nativeResponseValue;
20820 // void OpenChannel_set_to_self_delay(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
20822 export function OpenChannel_set_to_self_delay(this_ptr: number, val: number): void {
20823 if(!isWasmInitialized) {
20824 throw new Error("initializeWasm() must be awaited first!");
20826 const nativeResponseValue = wasm.TS_OpenChannel_set_to_self_delay(this_ptr, val);
20827 // debug statements here
20829 // uint16_t OpenChannel_get_max_accepted_htlcs(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20831 export function OpenChannel_get_max_accepted_htlcs(this_ptr: number): number {
20832 if(!isWasmInitialized) {
20833 throw new Error("initializeWasm() must be awaited first!");
20835 const nativeResponseValue = wasm.TS_OpenChannel_get_max_accepted_htlcs(this_ptr);
20836 return nativeResponseValue;
20838 // void OpenChannel_set_max_accepted_htlcs(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint16_t val);
20840 export function OpenChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
20841 if(!isWasmInitialized) {
20842 throw new Error("initializeWasm() must be awaited first!");
20844 const nativeResponseValue = wasm.TS_OpenChannel_set_max_accepted_htlcs(this_ptr, val);
20845 // debug statements here
20847 // struct LDKPublicKey OpenChannel_get_funding_pubkey(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20849 export function OpenChannel_get_funding_pubkey(this_ptr: number): number {
20850 if(!isWasmInitialized) {
20851 throw new Error("initializeWasm() must be awaited first!");
20853 const nativeResponseValue = wasm.TS_OpenChannel_get_funding_pubkey(this_ptr);
20854 return nativeResponseValue;
20856 // void OpenChannel_set_funding_pubkey(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20858 export function OpenChannel_set_funding_pubkey(this_ptr: number, val: number): void {
20859 if(!isWasmInitialized) {
20860 throw new Error("initializeWasm() must be awaited first!");
20862 const nativeResponseValue = wasm.TS_OpenChannel_set_funding_pubkey(this_ptr, val);
20863 // debug statements here
20865 // struct LDKPublicKey OpenChannel_get_revocation_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20867 export function OpenChannel_get_revocation_basepoint(this_ptr: number): number {
20868 if(!isWasmInitialized) {
20869 throw new Error("initializeWasm() must be awaited first!");
20871 const nativeResponseValue = wasm.TS_OpenChannel_get_revocation_basepoint(this_ptr);
20872 return nativeResponseValue;
20874 // void OpenChannel_set_revocation_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20876 export function OpenChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
20877 if(!isWasmInitialized) {
20878 throw new Error("initializeWasm() must be awaited first!");
20880 const nativeResponseValue = wasm.TS_OpenChannel_set_revocation_basepoint(this_ptr, val);
20881 // debug statements here
20883 // struct LDKPublicKey OpenChannel_get_payment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20885 export function OpenChannel_get_payment_point(this_ptr: number): number {
20886 if(!isWasmInitialized) {
20887 throw new Error("initializeWasm() must be awaited first!");
20889 const nativeResponseValue = wasm.TS_OpenChannel_get_payment_point(this_ptr);
20890 return nativeResponseValue;
20892 // void OpenChannel_set_payment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20894 export function OpenChannel_set_payment_point(this_ptr: number, val: number): void {
20895 if(!isWasmInitialized) {
20896 throw new Error("initializeWasm() must be awaited first!");
20898 const nativeResponseValue = wasm.TS_OpenChannel_set_payment_point(this_ptr, val);
20899 // debug statements here
20901 // struct LDKPublicKey OpenChannel_get_delayed_payment_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20903 export function OpenChannel_get_delayed_payment_basepoint(this_ptr: number): number {
20904 if(!isWasmInitialized) {
20905 throw new Error("initializeWasm() must be awaited first!");
20907 const nativeResponseValue = wasm.TS_OpenChannel_get_delayed_payment_basepoint(this_ptr);
20908 return nativeResponseValue;
20910 // void OpenChannel_set_delayed_payment_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20912 export function OpenChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
20913 if(!isWasmInitialized) {
20914 throw new Error("initializeWasm() must be awaited first!");
20916 const nativeResponseValue = wasm.TS_OpenChannel_set_delayed_payment_basepoint(this_ptr, val);
20917 // debug statements here
20919 // struct LDKPublicKey OpenChannel_get_htlc_basepoint(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20921 export function OpenChannel_get_htlc_basepoint(this_ptr: number): number {
20922 if(!isWasmInitialized) {
20923 throw new Error("initializeWasm() must be awaited first!");
20925 const nativeResponseValue = wasm.TS_OpenChannel_get_htlc_basepoint(this_ptr);
20926 return nativeResponseValue;
20928 // void OpenChannel_set_htlc_basepoint(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20930 export function OpenChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
20931 if(!isWasmInitialized) {
20932 throw new Error("initializeWasm() must be awaited first!");
20934 const nativeResponseValue = wasm.TS_OpenChannel_set_htlc_basepoint(this_ptr, val);
20935 // debug statements here
20937 // struct LDKPublicKey OpenChannel_get_first_per_commitment_point(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20939 export function OpenChannel_get_first_per_commitment_point(this_ptr: number): number {
20940 if(!isWasmInitialized) {
20941 throw new Error("initializeWasm() must be awaited first!");
20943 const nativeResponseValue = wasm.TS_OpenChannel_get_first_per_commitment_point(this_ptr);
20944 return nativeResponseValue;
20946 // void OpenChannel_set_first_per_commitment_point(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
20948 export function OpenChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
20949 if(!isWasmInitialized) {
20950 throw new Error("initializeWasm() must be awaited first!");
20952 const nativeResponseValue = wasm.TS_OpenChannel_set_first_per_commitment_point(this_ptr, val);
20953 // debug statements here
20955 // uint8_t OpenChannel_get_channel_flags(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20957 export function OpenChannel_get_channel_flags(this_ptr: number): number {
20958 if(!isWasmInitialized) {
20959 throw new Error("initializeWasm() must be awaited first!");
20961 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_flags(this_ptr);
20962 return nativeResponseValue;
20964 // void OpenChannel_set_channel_flags(struct LDKOpenChannel *NONNULL_PTR this_ptr, uint8_t val);
20966 export function OpenChannel_set_channel_flags(this_ptr: number, val: number): void {
20967 if(!isWasmInitialized) {
20968 throw new Error("initializeWasm() must be awaited first!");
20970 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_flags(this_ptr, val);
20971 // debug statements here
20973 // struct LDKChannelTypeFeatures OpenChannel_get_channel_type(const struct LDKOpenChannel *NONNULL_PTR this_ptr);
20975 export function OpenChannel_get_channel_type(this_ptr: number): number {
20976 if(!isWasmInitialized) {
20977 throw new Error("initializeWasm() must be awaited first!");
20979 const nativeResponseValue = wasm.TS_OpenChannel_get_channel_type(this_ptr);
20980 return nativeResponseValue;
20982 // void OpenChannel_set_channel_type(struct LDKOpenChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
20984 export function OpenChannel_set_channel_type(this_ptr: number, val: number): void {
20985 if(!isWasmInitialized) {
20986 throw new Error("initializeWasm() must be awaited first!");
20988 const nativeResponseValue = wasm.TS_OpenChannel_set_channel_type(this_ptr, val);
20989 // debug statements here
20991 // uintptr_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg);
20993 export function OpenChannel_clone_ptr(arg: number): number {
20994 if(!isWasmInitialized) {
20995 throw new Error("initializeWasm() must be awaited first!");
20997 const nativeResponseValue = wasm.TS_OpenChannel_clone_ptr(arg);
20998 return nativeResponseValue;
21000 // struct LDKOpenChannel OpenChannel_clone(const struct LDKOpenChannel *NONNULL_PTR orig);
21002 export function OpenChannel_clone(orig: number): number {
21003 if(!isWasmInitialized) {
21004 throw new Error("initializeWasm() must be awaited first!");
21006 const nativeResponseValue = wasm.TS_OpenChannel_clone(orig);
21007 return nativeResponseValue;
21009 // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
21011 export function AcceptChannel_free(this_obj: number): void {
21012 if(!isWasmInitialized) {
21013 throw new Error("initializeWasm() must be awaited first!");
21015 const nativeResponseValue = wasm.TS_AcceptChannel_free(this_obj);
21016 // debug statements here
21018 // const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
21020 export function AcceptChannel_get_temporary_channel_id(this_ptr: number): number {
21021 if(!isWasmInitialized) {
21022 throw new Error("initializeWasm() must be awaited first!");
21024 const nativeResponseValue = wasm.TS_AcceptChannel_get_temporary_channel_id(this_ptr);
21025 return nativeResponseValue;
21027 // void AcceptChannel_set_temporary_channel_id(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21029 export function AcceptChannel_set_temporary_channel_id(this_ptr: number, val: number): void {
21030 if(!isWasmInitialized) {
21031 throw new Error("initializeWasm() must be awaited first!");
21033 const nativeResponseValue = wasm.TS_AcceptChannel_set_temporary_channel_id(this_ptr, val);
21034 // debug statements here
21036 // uint64_t AcceptChannel_get_dust_limit_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21038 export function AcceptChannel_get_dust_limit_satoshis(this_ptr: number): bigint {
21039 if(!isWasmInitialized) {
21040 throw new Error("initializeWasm() must be awaited first!");
21042 const nativeResponseValue = wasm.TS_AcceptChannel_get_dust_limit_satoshis(this_ptr);
21043 return nativeResponseValue;
21045 // void AcceptChannel_set_dust_limit_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21047 export function AcceptChannel_set_dust_limit_satoshis(this_ptr: number, val: bigint): void {
21048 if(!isWasmInitialized) {
21049 throw new Error("initializeWasm() must be awaited first!");
21051 const nativeResponseValue = wasm.TS_AcceptChannel_set_dust_limit_satoshis(this_ptr, val);
21052 // debug statements here
21054 // uint64_t AcceptChannel_get_max_htlc_value_in_flight_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21056 export function AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr: number): bigint {
21057 if(!isWasmInitialized) {
21058 throw new Error("initializeWasm() must be awaited first!");
21060 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_htlc_value_in_flight_msat(this_ptr);
21061 return nativeResponseValue;
21063 // void AcceptChannel_set_max_htlc_value_in_flight_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21065 export function AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr: number, val: bigint): void {
21066 if(!isWasmInitialized) {
21067 throw new Error("initializeWasm() must be awaited first!");
21069 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_htlc_value_in_flight_msat(this_ptr, val);
21070 // debug statements here
21072 // uint64_t AcceptChannel_get_channel_reserve_satoshis(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21074 export function AcceptChannel_get_channel_reserve_satoshis(this_ptr: number): bigint {
21075 if(!isWasmInitialized) {
21076 throw new Error("initializeWasm() must be awaited first!");
21078 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_reserve_satoshis(this_ptr);
21079 return nativeResponseValue;
21081 // void AcceptChannel_set_channel_reserve_satoshis(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21083 export function AcceptChannel_set_channel_reserve_satoshis(this_ptr: number, val: bigint): void {
21084 if(!isWasmInitialized) {
21085 throw new Error("initializeWasm() must be awaited first!");
21087 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_reserve_satoshis(this_ptr, val);
21088 // debug statements here
21090 // uint64_t AcceptChannel_get_htlc_minimum_msat(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21092 export function AcceptChannel_get_htlc_minimum_msat(this_ptr: number): bigint {
21093 if(!isWasmInitialized) {
21094 throw new Error("initializeWasm() must be awaited first!");
21096 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_minimum_msat(this_ptr);
21097 return nativeResponseValue;
21099 // void AcceptChannel_set_htlc_minimum_msat(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint64_t val);
21101 export function AcceptChannel_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
21102 if(!isWasmInitialized) {
21103 throw new Error("initializeWasm() must be awaited first!");
21105 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_minimum_msat(this_ptr, val);
21106 // debug statements here
21108 // uint32_t AcceptChannel_get_minimum_depth(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21110 export function AcceptChannel_get_minimum_depth(this_ptr: number): number {
21111 if(!isWasmInitialized) {
21112 throw new Error("initializeWasm() must be awaited first!");
21114 const nativeResponseValue = wasm.TS_AcceptChannel_get_minimum_depth(this_ptr);
21115 return nativeResponseValue;
21117 // void AcceptChannel_set_minimum_depth(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint32_t val);
21119 export function AcceptChannel_set_minimum_depth(this_ptr: number, val: number): void {
21120 if(!isWasmInitialized) {
21121 throw new Error("initializeWasm() must be awaited first!");
21123 const nativeResponseValue = wasm.TS_AcceptChannel_set_minimum_depth(this_ptr, val);
21124 // debug statements here
21126 // uint16_t AcceptChannel_get_to_self_delay(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21128 export function AcceptChannel_get_to_self_delay(this_ptr: number): number {
21129 if(!isWasmInitialized) {
21130 throw new Error("initializeWasm() must be awaited first!");
21132 const nativeResponseValue = wasm.TS_AcceptChannel_get_to_self_delay(this_ptr);
21133 return nativeResponseValue;
21135 // void AcceptChannel_set_to_self_delay(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
21137 export function AcceptChannel_set_to_self_delay(this_ptr: number, val: number): void {
21138 if(!isWasmInitialized) {
21139 throw new Error("initializeWasm() must be awaited first!");
21141 const nativeResponseValue = wasm.TS_AcceptChannel_set_to_self_delay(this_ptr, val);
21142 // debug statements here
21144 // uint16_t AcceptChannel_get_max_accepted_htlcs(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21146 export function AcceptChannel_get_max_accepted_htlcs(this_ptr: number): number {
21147 if(!isWasmInitialized) {
21148 throw new Error("initializeWasm() must be awaited first!");
21150 const nativeResponseValue = wasm.TS_AcceptChannel_get_max_accepted_htlcs(this_ptr);
21151 return nativeResponseValue;
21153 // void AcceptChannel_set_max_accepted_htlcs(struct LDKAcceptChannel *NONNULL_PTR this_ptr, uint16_t val);
21155 export function AcceptChannel_set_max_accepted_htlcs(this_ptr: number, val: number): void {
21156 if(!isWasmInitialized) {
21157 throw new Error("initializeWasm() must be awaited first!");
21159 const nativeResponseValue = wasm.TS_AcceptChannel_set_max_accepted_htlcs(this_ptr, val);
21160 // debug statements here
21162 // struct LDKPublicKey AcceptChannel_get_funding_pubkey(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21164 export function AcceptChannel_get_funding_pubkey(this_ptr: number): number {
21165 if(!isWasmInitialized) {
21166 throw new Error("initializeWasm() must be awaited first!");
21168 const nativeResponseValue = wasm.TS_AcceptChannel_get_funding_pubkey(this_ptr);
21169 return nativeResponseValue;
21171 // void AcceptChannel_set_funding_pubkey(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21173 export function AcceptChannel_set_funding_pubkey(this_ptr: number, val: number): void {
21174 if(!isWasmInitialized) {
21175 throw new Error("initializeWasm() must be awaited first!");
21177 const nativeResponseValue = wasm.TS_AcceptChannel_set_funding_pubkey(this_ptr, val);
21178 // debug statements here
21180 // struct LDKPublicKey AcceptChannel_get_revocation_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21182 export function AcceptChannel_get_revocation_basepoint(this_ptr: number): number {
21183 if(!isWasmInitialized) {
21184 throw new Error("initializeWasm() must be awaited first!");
21186 const nativeResponseValue = wasm.TS_AcceptChannel_get_revocation_basepoint(this_ptr);
21187 return nativeResponseValue;
21189 // void AcceptChannel_set_revocation_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21191 export function AcceptChannel_set_revocation_basepoint(this_ptr: number, val: number): void {
21192 if(!isWasmInitialized) {
21193 throw new Error("initializeWasm() must be awaited first!");
21195 const nativeResponseValue = wasm.TS_AcceptChannel_set_revocation_basepoint(this_ptr, val);
21196 // debug statements here
21198 // struct LDKPublicKey AcceptChannel_get_payment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21200 export function AcceptChannel_get_payment_point(this_ptr: number): number {
21201 if(!isWasmInitialized) {
21202 throw new Error("initializeWasm() must be awaited first!");
21204 const nativeResponseValue = wasm.TS_AcceptChannel_get_payment_point(this_ptr);
21205 return nativeResponseValue;
21207 // void AcceptChannel_set_payment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21209 export function AcceptChannel_set_payment_point(this_ptr: number, val: number): void {
21210 if(!isWasmInitialized) {
21211 throw new Error("initializeWasm() must be awaited first!");
21213 const nativeResponseValue = wasm.TS_AcceptChannel_set_payment_point(this_ptr, val);
21214 // debug statements here
21216 // struct LDKPublicKey AcceptChannel_get_delayed_payment_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21218 export function AcceptChannel_get_delayed_payment_basepoint(this_ptr: number): number {
21219 if(!isWasmInitialized) {
21220 throw new Error("initializeWasm() must be awaited first!");
21222 const nativeResponseValue = wasm.TS_AcceptChannel_get_delayed_payment_basepoint(this_ptr);
21223 return nativeResponseValue;
21225 // void AcceptChannel_set_delayed_payment_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21227 export function AcceptChannel_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
21228 if(!isWasmInitialized) {
21229 throw new Error("initializeWasm() must be awaited first!");
21231 const nativeResponseValue = wasm.TS_AcceptChannel_set_delayed_payment_basepoint(this_ptr, val);
21232 // debug statements here
21234 // struct LDKPublicKey AcceptChannel_get_htlc_basepoint(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21236 export function AcceptChannel_get_htlc_basepoint(this_ptr: number): number {
21237 if(!isWasmInitialized) {
21238 throw new Error("initializeWasm() must be awaited first!");
21240 const nativeResponseValue = wasm.TS_AcceptChannel_get_htlc_basepoint(this_ptr);
21241 return nativeResponseValue;
21243 // void AcceptChannel_set_htlc_basepoint(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21245 export function AcceptChannel_set_htlc_basepoint(this_ptr: number, val: number): void {
21246 if(!isWasmInitialized) {
21247 throw new Error("initializeWasm() must be awaited first!");
21249 const nativeResponseValue = wasm.TS_AcceptChannel_set_htlc_basepoint(this_ptr, val);
21250 // debug statements here
21252 // struct LDKPublicKey AcceptChannel_get_first_per_commitment_point(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21254 export function AcceptChannel_get_first_per_commitment_point(this_ptr: number): number {
21255 if(!isWasmInitialized) {
21256 throw new Error("initializeWasm() must be awaited first!");
21258 const nativeResponseValue = wasm.TS_AcceptChannel_get_first_per_commitment_point(this_ptr);
21259 return nativeResponseValue;
21261 // void AcceptChannel_set_first_per_commitment_point(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21263 export function AcceptChannel_set_first_per_commitment_point(this_ptr: number, val: number): void {
21264 if(!isWasmInitialized) {
21265 throw new Error("initializeWasm() must be awaited first!");
21267 const nativeResponseValue = wasm.TS_AcceptChannel_set_first_per_commitment_point(this_ptr, val);
21268 // debug statements here
21270 // struct LDKChannelTypeFeatures AcceptChannel_get_channel_type(const struct LDKAcceptChannel *NONNULL_PTR this_ptr);
21272 export function AcceptChannel_get_channel_type(this_ptr: number): number {
21273 if(!isWasmInitialized) {
21274 throw new Error("initializeWasm() must be awaited first!");
21276 const nativeResponseValue = wasm.TS_AcceptChannel_get_channel_type(this_ptr);
21277 return nativeResponseValue;
21279 // void AcceptChannel_set_channel_type(struct LDKAcceptChannel *NONNULL_PTR this_ptr, struct LDKChannelTypeFeatures val);
21281 export function AcceptChannel_set_channel_type(this_ptr: number, val: number): void {
21282 if(!isWasmInitialized) {
21283 throw new Error("initializeWasm() must be awaited first!");
21285 const nativeResponseValue = wasm.TS_AcceptChannel_set_channel_type(this_ptr, val);
21286 // debug statements here
21288 // uintptr_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg);
21290 export function AcceptChannel_clone_ptr(arg: number): number {
21291 if(!isWasmInitialized) {
21292 throw new Error("initializeWasm() must be awaited first!");
21294 const nativeResponseValue = wasm.TS_AcceptChannel_clone_ptr(arg);
21295 return nativeResponseValue;
21297 // struct LDKAcceptChannel AcceptChannel_clone(const struct LDKAcceptChannel *NONNULL_PTR orig);
21299 export function AcceptChannel_clone(orig: number): number {
21300 if(!isWasmInitialized) {
21301 throw new Error("initializeWasm() must be awaited first!");
21303 const nativeResponseValue = wasm.TS_AcceptChannel_clone(orig);
21304 return nativeResponseValue;
21306 // void FundingCreated_free(struct LDKFundingCreated this_obj);
21308 export function FundingCreated_free(this_obj: number): void {
21309 if(!isWasmInitialized) {
21310 throw new Error("initializeWasm() must be awaited first!");
21312 const nativeResponseValue = wasm.TS_FundingCreated_free(this_obj);
21313 // debug statements here
21315 // const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21317 export function FundingCreated_get_temporary_channel_id(this_ptr: number): number {
21318 if(!isWasmInitialized) {
21319 throw new Error("initializeWasm() must be awaited first!");
21321 const nativeResponseValue = wasm.TS_FundingCreated_get_temporary_channel_id(this_ptr);
21322 return nativeResponseValue;
21324 // void FundingCreated_set_temporary_channel_id(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21326 export function FundingCreated_set_temporary_channel_id(this_ptr: number, val: number): void {
21327 if(!isWasmInitialized) {
21328 throw new Error("initializeWasm() must be awaited first!");
21330 const nativeResponseValue = wasm.TS_FundingCreated_set_temporary_channel_id(this_ptr, val);
21331 // debug statements here
21333 // const uint8_t (*FundingCreated_get_funding_txid(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
21335 export function FundingCreated_get_funding_txid(this_ptr: number): number {
21336 if(!isWasmInitialized) {
21337 throw new Error("initializeWasm() must be awaited first!");
21339 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_txid(this_ptr);
21340 return nativeResponseValue;
21342 // void FundingCreated_set_funding_txid(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21344 export function FundingCreated_set_funding_txid(this_ptr: number, val: number): void {
21345 if(!isWasmInitialized) {
21346 throw new Error("initializeWasm() must be awaited first!");
21348 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_txid(this_ptr, val);
21349 // debug statements here
21351 // uint16_t FundingCreated_get_funding_output_index(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21353 export function FundingCreated_get_funding_output_index(this_ptr: number): number {
21354 if(!isWasmInitialized) {
21355 throw new Error("initializeWasm() must be awaited first!");
21357 const nativeResponseValue = wasm.TS_FundingCreated_get_funding_output_index(this_ptr);
21358 return nativeResponseValue;
21360 // void FundingCreated_set_funding_output_index(struct LDKFundingCreated *NONNULL_PTR this_ptr, uint16_t val);
21362 export function FundingCreated_set_funding_output_index(this_ptr: number, val: number): void {
21363 if(!isWasmInitialized) {
21364 throw new Error("initializeWasm() must be awaited first!");
21366 const nativeResponseValue = wasm.TS_FundingCreated_set_funding_output_index(this_ptr, val);
21367 // debug statements here
21369 // struct LDKSignature FundingCreated_get_signature(const struct LDKFundingCreated *NONNULL_PTR this_ptr);
21371 export function FundingCreated_get_signature(this_ptr: number): number {
21372 if(!isWasmInitialized) {
21373 throw new Error("initializeWasm() must be awaited first!");
21375 const nativeResponseValue = wasm.TS_FundingCreated_get_signature(this_ptr);
21376 return nativeResponseValue;
21378 // void FundingCreated_set_signature(struct LDKFundingCreated *NONNULL_PTR this_ptr, struct LDKSignature val);
21380 export function FundingCreated_set_signature(this_ptr: number, val: number): void {
21381 if(!isWasmInitialized) {
21382 throw new Error("initializeWasm() must be awaited first!");
21384 const nativeResponseValue = wasm.TS_FundingCreated_set_signature(this_ptr, val);
21385 // debug statements here
21387 // 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);
21389 export function FundingCreated_new(temporary_channel_id_arg: number, funding_txid_arg: number, funding_output_index_arg: number, signature_arg: number): number {
21390 if(!isWasmInitialized) {
21391 throw new Error("initializeWasm() must be awaited first!");
21393 const nativeResponseValue = wasm.TS_FundingCreated_new(temporary_channel_id_arg, funding_txid_arg, funding_output_index_arg, signature_arg);
21394 return nativeResponseValue;
21396 // uintptr_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg);
21398 export function FundingCreated_clone_ptr(arg: number): number {
21399 if(!isWasmInitialized) {
21400 throw new Error("initializeWasm() must be awaited first!");
21402 const nativeResponseValue = wasm.TS_FundingCreated_clone_ptr(arg);
21403 return nativeResponseValue;
21405 // struct LDKFundingCreated FundingCreated_clone(const struct LDKFundingCreated *NONNULL_PTR orig);
21407 export function FundingCreated_clone(orig: number): number {
21408 if(!isWasmInitialized) {
21409 throw new Error("initializeWasm() must be awaited first!");
21411 const nativeResponseValue = wasm.TS_FundingCreated_clone(orig);
21412 return nativeResponseValue;
21414 // void FundingSigned_free(struct LDKFundingSigned this_obj);
21416 export function FundingSigned_free(this_obj: number): void {
21417 if(!isWasmInitialized) {
21418 throw new Error("initializeWasm() must be awaited first!");
21420 const nativeResponseValue = wasm.TS_FundingSigned_free(this_obj);
21421 // debug statements here
21423 // const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
21425 export function FundingSigned_get_channel_id(this_ptr: number): number {
21426 if(!isWasmInitialized) {
21427 throw new Error("initializeWasm() must be awaited first!");
21429 const nativeResponseValue = wasm.TS_FundingSigned_get_channel_id(this_ptr);
21430 return nativeResponseValue;
21432 // void FundingSigned_set_channel_id(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21434 export function FundingSigned_set_channel_id(this_ptr: number, val: number): void {
21435 if(!isWasmInitialized) {
21436 throw new Error("initializeWasm() must be awaited first!");
21438 const nativeResponseValue = wasm.TS_FundingSigned_set_channel_id(this_ptr, val);
21439 // debug statements here
21441 // struct LDKSignature FundingSigned_get_signature(const struct LDKFundingSigned *NONNULL_PTR this_ptr);
21443 export function FundingSigned_get_signature(this_ptr: number): number {
21444 if(!isWasmInitialized) {
21445 throw new Error("initializeWasm() must be awaited first!");
21447 const nativeResponseValue = wasm.TS_FundingSigned_get_signature(this_ptr);
21448 return nativeResponseValue;
21450 // void FundingSigned_set_signature(struct LDKFundingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21452 export function FundingSigned_set_signature(this_ptr: number, val: number): void {
21453 if(!isWasmInitialized) {
21454 throw new Error("initializeWasm() must be awaited first!");
21456 const nativeResponseValue = wasm.TS_FundingSigned_set_signature(this_ptr, val);
21457 // debug statements here
21459 // MUST_USE_RES struct LDKFundingSigned FundingSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg);
21461 export function FundingSigned_new(channel_id_arg: number, signature_arg: number): number {
21462 if(!isWasmInitialized) {
21463 throw new Error("initializeWasm() must be awaited first!");
21465 const nativeResponseValue = wasm.TS_FundingSigned_new(channel_id_arg, signature_arg);
21466 return nativeResponseValue;
21468 // uintptr_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg);
21470 export function FundingSigned_clone_ptr(arg: number): number {
21471 if(!isWasmInitialized) {
21472 throw new Error("initializeWasm() must be awaited first!");
21474 const nativeResponseValue = wasm.TS_FundingSigned_clone_ptr(arg);
21475 return nativeResponseValue;
21477 // struct LDKFundingSigned FundingSigned_clone(const struct LDKFundingSigned *NONNULL_PTR orig);
21479 export function FundingSigned_clone(orig: number): number {
21480 if(!isWasmInitialized) {
21481 throw new Error("initializeWasm() must be awaited first!");
21483 const nativeResponseValue = wasm.TS_FundingSigned_clone(orig);
21484 return nativeResponseValue;
21486 // void ChannelReady_free(struct LDKChannelReady this_obj);
21488 export function ChannelReady_free(this_obj: number): void {
21489 if(!isWasmInitialized) {
21490 throw new Error("initializeWasm() must be awaited first!");
21492 const nativeResponseValue = wasm.TS_ChannelReady_free(this_obj);
21493 // debug statements here
21495 // const uint8_t (*ChannelReady_get_channel_id(const struct LDKChannelReady *NONNULL_PTR this_ptr))[32];
21497 export function ChannelReady_get_channel_id(this_ptr: number): number {
21498 if(!isWasmInitialized) {
21499 throw new Error("initializeWasm() must be awaited first!");
21501 const nativeResponseValue = wasm.TS_ChannelReady_get_channel_id(this_ptr);
21502 return nativeResponseValue;
21504 // void ChannelReady_set_channel_id(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21506 export function ChannelReady_set_channel_id(this_ptr: number, val: number): void {
21507 if(!isWasmInitialized) {
21508 throw new Error("initializeWasm() must be awaited first!");
21510 const nativeResponseValue = wasm.TS_ChannelReady_set_channel_id(this_ptr, val);
21511 // debug statements here
21513 // struct LDKPublicKey ChannelReady_get_next_per_commitment_point(const struct LDKChannelReady *NONNULL_PTR this_ptr);
21515 export function ChannelReady_get_next_per_commitment_point(this_ptr: number): number {
21516 if(!isWasmInitialized) {
21517 throw new Error("initializeWasm() must be awaited first!");
21519 const nativeResponseValue = wasm.TS_ChannelReady_get_next_per_commitment_point(this_ptr);
21520 return nativeResponseValue;
21522 // void ChannelReady_set_next_per_commitment_point(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKPublicKey val);
21524 export function ChannelReady_set_next_per_commitment_point(this_ptr: number, val: number): void {
21525 if(!isWasmInitialized) {
21526 throw new Error("initializeWasm() must be awaited first!");
21528 const nativeResponseValue = wasm.TS_ChannelReady_set_next_per_commitment_point(this_ptr, val);
21529 // debug statements here
21531 // struct LDKCOption_u64Z ChannelReady_get_short_channel_id_alias(const struct LDKChannelReady *NONNULL_PTR this_ptr);
21533 export function ChannelReady_get_short_channel_id_alias(this_ptr: number): number {
21534 if(!isWasmInitialized) {
21535 throw new Error("initializeWasm() must be awaited first!");
21537 const nativeResponseValue = wasm.TS_ChannelReady_get_short_channel_id_alias(this_ptr);
21538 return nativeResponseValue;
21540 // void ChannelReady_set_short_channel_id_alias(struct LDKChannelReady *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
21542 export function ChannelReady_set_short_channel_id_alias(this_ptr: number, val: number): void {
21543 if(!isWasmInitialized) {
21544 throw new Error("initializeWasm() must be awaited first!");
21546 const nativeResponseValue = wasm.TS_ChannelReady_set_short_channel_id_alias(this_ptr, val);
21547 // debug statements here
21549 // 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);
21551 export function ChannelReady_new(channel_id_arg: number, next_per_commitment_point_arg: number, short_channel_id_alias_arg: number): number {
21552 if(!isWasmInitialized) {
21553 throw new Error("initializeWasm() must be awaited first!");
21555 const nativeResponseValue = wasm.TS_ChannelReady_new(channel_id_arg, next_per_commitment_point_arg, short_channel_id_alias_arg);
21556 return nativeResponseValue;
21558 // uintptr_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg);
21560 export function ChannelReady_clone_ptr(arg: number): number {
21561 if(!isWasmInitialized) {
21562 throw new Error("initializeWasm() must be awaited first!");
21564 const nativeResponseValue = wasm.TS_ChannelReady_clone_ptr(arg);
21565 return nativeResponseValue;
21567 // struct LDKChannelReady ChannelReady_clone(const struct LDKChannelReady *NONNULL_PTR orig);
21569 export function ChannelReady_clone(orig: number): number {
21570 if(!isWasmInitialized) {
21571 throw new Error("initializeWasm() must be awaited first!");
21573 const nativeResponseValue = wasm.TS_ChannelReady_clone(orig);
21574 return nativeResponseValue;
21576 // void Shutdown_free(struct LDKShutdown this_obj);
21578 export function Shutdown_free(this_obj: number): void {
21579 if(!isWasmInitialized) {
21580 throw new Error("initializeWasm() must be awaited first!");
21582 const nativeResponseValue = wasm.TS_Shutdown_free(this_obj);
21583 // debug statements here
21585 // const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
21587 export function Shutdown_get_channel_id(this_ptr: number): number {
21588 if(!isWasmInitialized) {
21589 throw new Error("initializeWasm() must be awaited first!");
21591 const nativeResponseValue = wasm.TS_Shutdown_get_channel_id(this_ptr);
21592 return nativeResponseValue;
21594 // void Shutdown_set_channel_id(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21596 export function Shutdown_set_channel_id(this_ptr: number, val: number): void {
21597 if(!isWasmInitialized) {
21598 throw new Error("initializeWasm() must be awaited first!");
21600 const nativeResponseValue = wasm.TS_Shutdown_set_channel_id(this_ptr, val);
21601 // debug statements here
21603 // struct LDKu8slice Shutdown_get_scriptpubkey(const struct LDKShutdown *NONNULL_PTR this_ptr);
21605 export function Shutdown_get_scriptpubkey(this_ptr: number): number {
21606 if(!isWasmInitialized) {
21607 throw new Error("initializeWasm() must be awaited first!");
21609 const nativeResponseValue = wasm.TS_Shutdown_get_scriptpubkey(this_ptr);
21610 return nativeResponseValue;
21612 // void Shutdown_set_scriptpubkey(struct LDKShutdown *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
21614 export function Shutdown_set_scriptpubkey(this_ptr: number, val: number): void {
21615 if(!isWasmInitialized) {
21616 throw new Error("initializeWasm() must be awaited first!");
21618 const nativeResponseValue = wasm.TS_Shutdown_set_scriptpubkey(this_ptr, val);
21619 // debug statements here
21621 // MUST_USE_RES struct LDKShutdown Shutdown_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKCVec_u8Z scriptpubkey_arg);
21623 export function Shutdown_new(channel_id_arg: number, scriptpubkey_arg: number): number {
21624 if(!isWasmInitialized) {
21625 throw new Error("initializeWasm() must be awaited first!");
21627 const nativeResponseValue = wasm.TS_Shutdown_new(channel_id_arg, scriptpubkey_arg);
21628 return nativeResponseValue;
21630 // uintptr_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg);
21632 export function Shutdown_clone_ptr(arg: number): number {
21633 if(!isWasmInitialized) {
21634 throw new Error("initializeWasm() must be awaited first!");
21636 const nativeResponseValue = wasm.TS_Shutdown_clone_ptr(arg);
21637 return nativeResponseValue;
21639 // struct LDKShutdown Shutdown_clone(const struct LDKShutdown *NONNULL_PTR orig);
21641 export function Shutdown_clone(orig: number): number {
21642 if(!isWasmInitialized) {
21643 throw new Error("initializeWasm() must be awaited first!");
21645 const nativeResponseValue = wasm.TS_Shutdown_clone(orig);
21646 return nativeResponseValue;
21648 // void ClosingSignedFeeRange_free(struct LDKClosingSignedFeeRange this_obj);
21650 export function ClosingSignedFeeRange_free(this_obj: number): void {
21651 if(!isWasmInitialized) {
21652 throw new Error("initializeWasm() must be awaited first!");
21654 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_free(this_obj);
21655 // debug statements here
21657 // uint64_t ClosingSignedFeeRange_get_min_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
21659 export function ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr: number): bigint {
21660 if(!isWasmInitialized) {
21661 throw new Error("initializeWasm() must be awaited first!");
21663 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_min_fee_satoshis(this_ptr);
21664 return nativeResponseValue;
21666 // void ClosingSignedFeeRange_set_min_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
21668 export function ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr: number, val: bigint): void {
21669 if(!isWasmInitialized) {
21670 throw new Error("initializeWasm() must be awaited first!");
21672 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_min_fee_satoshis(this_ptr, val);
21673 // debug statements here
21675 // uint64_t ClosingSignedFeeRange_get_max_fee_satoshis(const struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr);
21677 export function ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr: number): bigint {
21678 if(!isWasmInitialized) {
21679 throw new Error("initializeWasm() must be awaited first!");
21681 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_get_max_fee_satoshis(this_ptr);
21682 return nativeResponseValue;
21684 // void ClosingSignedFeeRange_set_max_fee_satoshis(struct LDKClosingSignedFeeRange *NONNULL_PTR this_ptr, uint64_t val);
21686 export function ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr: number, val: bigint): void {
21687 if(!isWasmInitialized) {
21688 throw new Error("initializeWasm() must be awaited first!");
21690 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_set_max_fee_satoshis(this_ptr, val);
21691 // debug statements here
21693 // MUST_USE_RES struct LDKClosingSignedFeeRange ClosingSignedFeeRange_new(uint64_t min_fee_satoshis_arg, uint64_t max_fee_satoshis_arg);
21695 export function ClosingSignedFeeRange_new(min_fee_satoshis_arg: bigint, max_fee_satoshis_arg: bigint): number {
21696 if(!isWasmInitialized) {
21697 throw new Error("initializeWasm() must be awaited first!");
21699 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
21700 return nativeResponseValue;
21702 // uintptr_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg);
21704 export function ClosingSignedFeeRange_clone_ptr(arg: number): number {
21705 if(!isWasmInitialized) {
21706 throw new Error("initializeWasm() must be awaited first!");
21708 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone_ptr(arg);
21709 return nativeResponseValue;
21711 // struct LDKClosingSignedFeeRange ClosingSignedFeeRange_clone(const struct LDKClosingSignedFeeRange *NONNULL_PTR orig);
21713 export function ClosingSignedFeeRange_clone(orig: number): number {
21714 if(!isWasmInitialized) {
21715 throw new Error("initializeWasm() must be awaited first!");
21717 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_clone(orig);
21718 return nativeResponseValue;
21720 // void ClosingSigned_free(struct LDKClosingSigned this_obj);
21722 export function ClosingSigned_free(this_obj: number): void {
21723 if(!isWasmInitialized) {
21724 throw new Error("initializeWasm() must be awaited first!");
21726 const nativeResponseValue = wasm.TS_ClosingSigned_free(this_obj);
21727 // debug statements here
21729 // const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
21731 export function ClosingSigned_get_channel_id(this_ptr: number): number {
21732 if(!isWasmInitialized) {
21733 throw new Error("initializeWasm() must be awaited first!");
21735 const nativeResponseValue = wasm.TS_ClosingSigned_get_channel_id(this_ptr);
21736 return nativeResponseValue;
21738 // void ClosingSigned_set_channel_id(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21740 export function ClosingSigned_set_channel_id(this_ptr: number, val: number): void {
21741 if(!isWasmInitialized) {
21742 throw new Error("initializeWasm() must be awaited first!");
21744 const nativeResponseValue = wasm.TS_ClosingSigned_set_channel_id(this_ptr, val);
21745 // debug statements here
21747 // uint64_t ClosingSigned_get_fee_satoshis(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
21749 export function ClosingSigned_get_fee_satoshis(this_ptr: number): bigint {
21750 if(!isWasmInitialized) {
21751 throw new Error("initializeWasm() must be awaited first!");
21753 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_satoshis(this_ptr);
21754 return nativeResponseValue;
21756 // void ClosingSigned_set_fee_satoshis(struct LDKClosingSigned *NONNULL_PTR this_ptr, uint64_t val);
21758 export function ClosingSigned_set_fee_satoshis(this_ptr: number, val: bigint): void {
21759 if(!isWasmInitialized) {
21760 throw new Error("initializeWasm() must be awaited first!");
21762 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_satoshis(this_ptr, val);
21763 // debug statements here
21765 // struct LDKSignature ClosingSigned_get_signature(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
21767 export function ClosingSigned_get_signature(this_ptr: number): number {
21768 if(!isWasmInitialized) {
21769 throw new Error("initializeWasm() must be awaited first!");
21771 const nativeResponseValue = wasm.TS_ClosingSigned_get_signature(this_ptr);
21772 return nativeResponseValue;
21774 // void ClosingSigned_set_signature(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
21776 export function ClosingSigned_set_signature(this_ptr: number, val: number): void {
21777 if(!isWasmInitialized) {
21778 throw new Error("initializeWasm() must be awaited first!");
21780 const nativeResponseValue = wasm.TS_ClosingSigned_set_signature(this_ptr, val);
21781 // debug statements here
21783 // struct LDKClosingSignedFeeRange ClosingSigned_get_fee_range(const struct LDKClosingSigned *NONNULL_PTR this_ptr);
21785 export function ClosingSigned_get_fee_range(this_ptr: number): number {
21786 if(!isWasmInitialized) {
21787 throw new Error("initializeWasm() must be awaited first!");
21789 const nativeResponseValue = wasm.TS_ClosingSigned_get_fee_range(this_ptr);
21790 return nativeResponseValue;
21792 // void ClosingSigned_set_fee_range(struct LDKClosingSigned *NONNULL_PTR this_ptr, struct LDKClosingSignedFeeRange val);
21794 export function ClosingSigned_set_fee_range(this_ptr: number, val: number): void {
21795 if(!isWasmInitialized) {
21796 throw new Error("initializeWasm() must be awaited first!");
21798 const nativeResponseValue = wasm.TS_ClosingSigned_set_fee_range(this_ptr, val);
21799 // debug statements here
21801 // 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);
21803 export function ClosingSigned_new(channel_id_arg: number, fee_satoshis_arg: bigint, signature_arg: number, fee_range_arg: number): number {
21804 if(!isWasmInitialized) {
21805 throw new Error("initializeWasm() must be awaited first!");
21807 const nativeResponseValue = wasm.TS_ClosingSigned_new(channel_id_arg, fee_satoshis_arg, signature_arg, fee_range_arg);
21808 return nativeResponseValue;
21810 // uintptr_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg);
21812 export function ClosingSigned_clone_ptr(arg: number): number {
21813 if(!isWasmInitialized) {
21814 throw new Error("initializeWasm() must be awaited first!");
21816 const nativeResponseValue = wasm.TS_ClosingSigned_clone_ptr(arg);
21817 return nativeResponseValue;
21819 // struct LDKClosingSigned ClosingSigned_clone(const struct LDKClosingSigned *NONNULL_PTR orig);
21821 export function ClosingSigned_clone(orig: number): number {
21822 if(!isWasmInitialized) {
21823 throw new Error("initializeWasm() must be awaited first!");
21825 const nativeResponseValue = wasm.TS_ClosingSigned_clone(orig);
21826 return nativeResponseValue;
21828 // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
21830 export function UpdateAddHTLC_free(this_obj: number): void {
21831 if(!isWasmInitialized) {
21832 throw new Error("initializeWasm() must be awaited first!");
21834 const nativeResponseValue = wasm.TS_UpdateAddHTLC_free(this_obj);
21835 // debug statements here
21837 // const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
21839 export function UpdateAddHTLC_get_channel_id(this_ptr: number): number {
21840 if(!isWasmInitialized) {
21841 throw new Error("initializeWasm() must be awaited first!");
21843 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_channel_id(this_ptr);
21844 return nativeResponseValue;
21846 // void UpdateAddHTLC_set_channel_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21848 export function UpdateAddHTLC_set_channel_id(this_ptr: number, val: number): void {
21849 if(!isWasmInitialized) {
21850 throw new Error("initializeWasm() must be awaited first!");
21852 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_channel_id(this_ptr, val);
21853 // debug statements here
21855 // uint64_t UpdateAddHTLC_get_htlc_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21857 export function UpdateAddHTLC_get_htlc_id(this_ptr: number): bigint {
21858 if(!isWasmInitialized) {
21859 throw new Error("initializeWasm() must be awaited first!");
21861 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_htlc_id(this_ptr);
21862 return nativeResponseValue;
21864 // void UpdateAddHTLC_set_htlc_id(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
21866 export function UpdateAddHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21867 if(!isWasmInitialized) {
21868 throw new Error("initializeWasm() must be awaited first!");
21870 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_htlc_id(this_ptr, val);
21871 // debug statements here
21873 // uint64_t UpdateAddHTLC_get_amount_msat(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21875 export function UpdateAddHTLC_get_amount_msat(this_ptr: number): bigint {
21876 if(!isWasmInitialized) {
21877 throw new Error("initializeWasm() must be awaited first!");
21879 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_amount_msat(this_ptr);
21880 return nativeResponseValue;
21882 // void UpdateAddHTLC_set_amount_msat(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint64_t val);
21884 export function UpdateAddHTLC_set_amount_msat(this_ptr: number, val: bigint): void {
21885 if(!isWasmInitialized) {
21886 throw new Error("initializeWasm() must be awaited first!");
21888 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_amount_msat(this_ptr, val);
21889 // debug statements here
21891 // const uint8_t (*UpdateAddHTLC_get_payment_hash(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
21893 export function UpdateAddHTLC_get_payment_hash(this_ptr: number): number {
21894 if(!isWasmInitialized) {
21895 throw new Error("initializeWasm() must be awaited first!");
21897 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_payment_hash(this_ptr);
21898 return nativeResponseValue;
21900 // void UpdateAddHTLC_set_payment_hash(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21902 export function UpdateAddHTLC_set_payment_hash(this_ptr: number, val: number): void {
21903 if(!isWasmInitialized) {
21904 throw new Error("initializeWasm() must be awaited first!");
21906 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_payment_hash(this_ptr, val);
21907 // debug statements here
21909 // uint32_t UpdateAddHTLC_get_cltv_expiry(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr);
21911 export function UpdateAddHTLC_get_cltv_expiry(this_ptr: number): number {
21912 if(!isWasmInitialized) {
21913 throw new Error("initializeWasm() must be awaited first!");
21915 const nativeResponseValue = wasm.TS_UpdateAddHTLC_get_cltv_expiry(this_ptr);
21916 return nativeResponseValue;
21918 // void UpdateAddHTLC_set_cltv_expiry(struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr, uint32_t val);
21920 export function UpdateAddHTLC_set_cltv_expiry(this_ptr: number, val: number): void {
21921 if(!isWasmInitialized) {
21922 throw new Error("initializeWasm() must be awaited first!");
21924 const nativeResponseValue = wasm.TS_UpdateAddHTLC_set_cltv_expiry(this_ptr, val);
21925 // debug statements here
21927 // uintptr_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg);
21929 export function UpdateAddHTLC_clone_ptr(arg: number): number {
21930 if(!isWasmInitialized) {
21931 throw new Error("initializeWasm() must be awaited first!");
21933 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone_ptr(arg);
21934 return nativeResponseValue;
21936 // struct LDKUpdateAddHTLC UpdateAddHTLC_clone(const struct LDKUpdateAddHTLC *NONNULL_PTR orig);
21938 export function UpdateAddHTLC_clone(orig: number): number {
21939 if(!isWasmInitialized) {
21940 throw new Error("initializeWasm() must be awaited first!");
21942 const nativeResponseValue = wasm.TS_UpdateAddHTLC_clone(orig);
21943 return nativeResponseValue;
21945 // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
21947 export function UpdateFulfillHTLC_free(this_obj: number): void {
21948 if(!isWasmInitialized) {
21949 throw new Error("initializeWasm() must be awaited first!");
21951 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_free(this_obj);
21952 // debug statements here
21954 // const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
21956 export function UpdateFulfillHTLC_get_channel_id(this_ptr: number): number {
21957 if(!isWasmInitialized) {
21958 throw new Error("initializeWasm() must be awaited first!");
21960 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_channel_id(this_ptr);
21961 return nativeResponseValue;
21963 // void UpdateFulfillHTLC_set_channel_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
21965 export function UpdateFulfillHTLC_set_channel_id(this_ptr: number, val: number): void {
21966 if(!isWasmInitialized) {
21967 throw new Error("initializeWasm() must be awaited first!");
21969 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_channel_id(this_ptr, val);
21970 // debug statements here
21972 // uint64_t UpdateFulfillHTLC_get_htlc_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr);
21974 export function UpdateFulfillHTLC_get_htlc_id(this_ptr: number): bigint {
21975 if(!isWasmInitialized) {
21976 throw new Error("initializeWasm() must be awaited first!");
21978 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_htlc_id(this_ptr);
21979 return nativeResponseValue;
21981 // void UpdateFulfillHTLC_set_htlc_id(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, uint64_t val);
21983 export function UpdateFulfillHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
21984 if(!isWasmInitialized) {
21985 throw new Error("initializeWasm() must be awaited first!");
21987 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_htlc_id(this_ptr, val);
21988 // debug statements here
21990 // const uint8_t (*UpdateFulfillHTLC_get_payment_preimage(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
21992 export function UpdateFulfillHTLC_get_payment_preimage(this_ptr: number): number {
21993 if(!isWasmInitialized) {
21994 throw new Error("initializeWasm() must be awaited first!");
21996 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_get_payment_preimage(this_ptr);
21997 return nativeResponseValue;
21999 // void UpdateFulfillHTLC_set_payment_preimage(struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22001 export function UpdateFulfillHTLC_set_payment_preimage(this_ptr: number, val: number): void {
22002 if(!isWasmInitialized) {
22003 throw new Error("initializeWasm() must be awaited first!");
22005 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_set_payment_preimage(this_ptr, val);
22006 // debug statements here
22008 // MUST_USE_RES struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_new(struct LDKThirtyTwoBytes channel_id_arg, uint64_t htlc_id_arg, struct LDKThirtyTwoBytes payment_preimage_arg);
22010 export function UpdateFulfillHTLC_new(channel_id_arg: number, htlc_id_arg: bigint, payment_preimage_arg: number): number {
22011 if(!isWasmInitialized) {
22012 throw new Error("initializeWasm() must be awaited first!");
22014 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_new(channel_id_arg, htlc_id_arg, payment_preimage_arg);
22015 return nativeResponseValue;
22017 // uintptr_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg);
22019 export function UpdateFulfillHTLC_clone_ptr(arg: number): number {
22020 if(!isWasmInitialized) {
22021 throw new Error("initializeWasm() must be awaited first!");
22023 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone_ptr(arg);
22024 return nativeResponseValue;
22026 // struct LDKUpdateFulfillHTLC UpdateFulfillHTLC_clone(const struct LDKUpdateFulfillHTLC *NONNULL_PTR orig);
22028 export function UpdateFulfillHTLC_clone(orig: number): number {
22029 if(!isWasmInitialized) {
22030 throw new Error("initializeWasm() must be awaited first!");
22032 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_clone(orig);
22033 return nativeResponseValue;
22035 // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
22037 export function UpdateFailHTLC_free(this_obj: number): void {
22038 if(!isWasmInitialized) {
22039 throw new Error("initializeWasm() must be awaited first!");
22041 const nativeResponseValue = wasm.TS_UpdateFailHTLC_free(this_obj);
22042 // debug statements here
22044 // const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
22046 export function UpdateFailHTLC_get_channel_id(this_ptr: number): number {
22047 if(!isWasmInitialized) {
22048 throw new Error("initializeWasm() must be awaited first!");
22050 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_channel_id(this_ptr);
22051 return nativeResponseValue;
22053 // void UpdateFailHTLC_set_channel_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22055 export function UpdateFailHTLC_set_channel_id(this_ptr: number, val: number): void {
22056 if(!isWasmInitialized) {
22057 throw new Error("initializeWasm() must be awaited first!");
22059 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_channel_id(this_ptr, val);
22060 // debug statements here
22062 // uint64_t UpdateFailHTLC_get_htlc_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr);
22064 export function UpdateFailHTLC_get_htlc_id(this_ptr: number): bigint {
22065 if(!isWasmInitialized) {
22066 throw new Error("initializeWasm() must be awaited first!");
22068 const nativeResponseValue = wasm.TS_UpdateFailHTLC_get_htlc_id(this_ptr);
22069 return nativeResponseValue;
22071 // void UpdateFailHTLC_set_htlc_id(struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr, uint64_t val);
22073 export function UpdateFailHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22074 if(!isWasmInitialized) {
22075 throw new Error("initializeWasm() must be awaited first!");
22077 const nativeResponseValue = wasm.TS_UpdateFailHTLC_set_htlc_id(this_ptr, val);
22078 // debug statements here
22080 // uintptr_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg);
22082 export function UpdateFailHTLC_clone_ptr(arg: number): number {
22083 if(!isWasmInitialized) {
22084 throw new Error("initializeWasm() must be awaited first!");
22086 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone_ptr(arg);
22087 return nativeResponseValue;
22089 // struct LDKUpdateFailHTLC UpdateFailHTLC_clone(const struct LDKUpdateFailHTLC *NONNULL_PTR orig);
22091 export function UpdateFailHTLC_clone(orig: number): number {
22092 if(!isWasmInitialized) {
22093 throw new Error("initializeWasm() must be awaited first!");
22095 const nativeResponseValue = wasm.TS_UpdateFailHTLC_clone(orig);
22096 return nativeResponseValue;
22098 // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
22100 export function UpdateFailMalformedHTLC_free(this_obj: number): void {
22101 if(!isWasmInitialized) {
22102 throw new Error("initializeWasm() must be awaited first!");
22104 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_free(this_obj);
22105 // debug statements here
22107 // const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
22109 export function UpdateFailMalformedHTLC_get_channel_id(this_ptr: number): number {
22110 if(!isWasmInitialized) {
22111 throw new Error("initializeWasm() must be awaited first!");
22113 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_channel_id(this_ptr);
22114 return nativeResponseValue;
22116 // void UpdateFailMalformedHTLC_set_channel_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22118 export function UpdateFailMalformedHTLC_set_channel_id(this_ptr: number, val: number): void {
22119 if(!isWasmInitialized) {
22120 throw new Error("initializeWasm() must be awaited first!");
22122 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_channel_id(this_ptr, val);
22123 // debug statements here
22125 // uint64_t UpdateFailMalformedHTLC_get_htlc_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
22127 export function UpdateFailMalformedHTLC_get_htlc_id(this_ptr: number): bigint {
22128 if(!isWasmInitialized) {
22129 throw new Error("initializeWasm() must be awaited first!");
22131 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_htlc_id(this_ptr);
22132 return nativeResponseValue;
22134 // void UpdateFailMalformedHTLC_set_htlc_id(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint64_t val);
22136 export function UpdateFailMalformedHTLC_set_htlc_id(this_ptr: number, val: bigint): void {
22137 if(!isWasmInitialized) {
22138 throw new Error("initializeWasm() must be awaited first!");
22140 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_htlc_id(this_ptr, val);
22141 // debug statements here
22143 // uint16_t UpdateFailMalformedHTLC_get_failure_code(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr);
22145 export function UpdateFailMalformedHTLC_get_failure_code(this_ptr: number): number {
22146 if(!isWasmInitialized) {
22147 throw new Error("initializeWasm() must be awaited first!");
22149 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_get_failure_code(this_ptr);
22150 return nativeResponseValue;
22152 // void UpdateFailMalformedHTLC_set_failure_code(struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr, uint16_t val);
22154 export function UpdateFailMalformedHTLC_set_failure_code(this_ptr: number, val: number): void {
22155 if(!isWasmInitialized) {
22156 throw new Error("initializeWasm() must be awaited first!");
22158 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_set_failure_code(this_ptr, val);
22159 // debug statements here
22161 // uintptr_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg);
22163 export function UpdateFailMalformedHTLC_clone_ptr(arg: number): number {
22164 if(!isWasmInitialized) {
22165 throw new Error("initializeWasm() must be awaited first!");
22167 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone_ptr(arg);
22168 return nativeResponseValue;
22170 // struct LDKUpdateFailMalformedHTLC UpdateFailMalformedHTLC_clone(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR orig);
22172 export function UpdateFailMalformedHTLC_clone(orig: number): number {
22173 if(!isWasmInitialized) {
22174 throw new Error("initializeWasm() must be awaited first!");
22176 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_clone(orig);
22177 return nativeResponseValue;
22179 // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
22181 export function CommitmentSigned_free(this_obj: number): void {
22182 if(!isWasmInitialized) {
22183 throw new Error("initializeWasm() must be awaited first!");
22185 const nativeResponseValue = wasm.TS_CommitmentSigned_free(this_obj);
22186 // debug statements here
22188 // const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
22190 export function CommitmentSigned_get_channel_id(this_ptr: number): number {
22191 if(!isWasmInitialized) {
22192 throw new Error("initializeWasm() must be awaited first!");
22194 const nativeResponseValue = wasm.TS_CommitmentSigned_get_channel_id(this_ptr);
22195 return nativeResponseValue;
22197 // void CommitmentSigned_set_channel_id(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22199 export function CommitmentSigned_set_channel_id(this_ptr: number, val: number): void {
22200 if(!isWasmInitialized) {
22201 throw new Error("initializeWasm() must be awaited first!");
22203 const nativeResponseValue = wasm.TS_CommitmentSigned_set_channel_id(this_ptr, val);
22204 // debug statements here
22206 // struct LDKSignature CommitmentSigned_get_signature(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr);
22208 export function CommitmentSigned_get_signature(this_ptr: number): number {
22209 if(!isWasmInitialized) {
22210 throw new Error("initializeWasm() must be awaited first!");
22212 const nativeResponseValue = wasm.TS_CommitmentSigned_get_signature(this_ptr);
22213 return nativeResponseValue;
22215 // void CommitmentSigned_set_signature(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKSignature val);
22217 export function CommitmentSigned_set_signature(this_ptr: number, val: number): void {
22218 if(!isWasmInitialized) {
22219 throw new Error("initializeWasm() must be awaited first!");
22221 const nativeResponseValue = wasm.TS_CommitmentSigned_set_signature(this_ptr, val);
22222 // debug statements here
22224 // void CommitmentSigned_set_htlc_signatures(struct LDKCommitmentSigned *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
22226 export function CommitmentSigned_set_htlc_signatures(this_ptr: number, val: number): void {
22227 if(!isWasmInitialized) {
22228 throw new Error("initializeWasm() must be awaited first!");
22230 const nativeResponseValue = wasm.TS_CommitmentSigned_set_htlc_signatures(this_ptr, val);
22231 // debug statements here
22233 // MUST_USE_RES struct LDKCommitmentSigned CommitmentSigned_new(struct LDKThirtyTwoBytes channel_id_arg, struct LDKSignature signature_arg, struct LDKCVec_SignatureZ htlc_signatures_arg);
22235 export function CommitmentSigned_new(channel_id_arg: number, signature_arg: number, htlc_signatures_arg: number): number {
22236 if(!isWasmInitialized) {
22237 throw new Error("initializeWasm() must be awaited first!");
22239 const nativeResponseValue = wasm.TS_CommitmentSigned_new(channel_id_arg, signature_arg, htlc_signatures_arg);
22240 return nativeResponseValue;
22242 // uintptr_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg);
22244 export function CommitmentSigned_clone_ptr(arg: number): number {
22245 if(!isWasmInitialized) {
22246 throw new Error("initializeWasm() must be awaited first!");
22248 const nativeResponseValue = wasm.TS_CommitmentSigned_clone_ptr(arg);
22249 return nativeResponseValue;
22251 // struct LDKCommitmentSigned CommitmentSigned_clone(const struct LDKCommitmentSigned *NONNULL_PTR orig);
22253 export function CommitmentSigned_clone(orig: number): number {
22254 if(!isWasmInitialized) {
22255 throw new Error("initializeWasm() must be awaited first!");
22257 const nativeResponseValue = wasm.TS_CommitmentSigned_clone(orig);
22258 return nativeResponseValue;
22260 // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
22262 export function RevokeAndACK_free(this_obj: number): void {
22263 if(!isWasmInitialized) {
22264 throw new Error("initializeWasm() must be awaited first!");
22266 const nativeResponseValue = wasm.TS_RevokeAndACK_free(this_obj);
22267 // debug statements here
22269 // const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22271 export function RevokeAndACK_get_channel_id(this_ptr: number): number {
22272 if(!isWasmInitialized) {
22273 throw new Error("initializeWasm() must be awaited first!");
22275 const nativeResponseValue = wasm.TS_RevokeAndACK_get_channel_id(this_ptr);
22276 return nativeResponseValue;
22278 // void RevokeAndACK_set_channel_id(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22280 export function RevokeAndACK_set_channel_id(this_ptr: number, val: number): void {
22281 if(!isWasmInitialized) {
22282 throw new Error("initializeWasm() must be awaited first!");
22284 const nativeResponseValue = wasm.TS_RevokeAndACK_set_channel_id(this_ptr, val);
22285 // debug statements here
22287 // const uint8_t (*RevokeAndACK_get_per_commitment_secret(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
22289 export function RevokeAndACK_get_per_commitment_secret(this_ptr: number): number {
22290 if(!isWasmInitialized) {
22291 throw new Error("initializeWasm() must be awaited first!");
22293 const nativeResponseValue = wasm.TS_RevokeAndACK_get_per_commitment_secret(this_ptr);
22294 return nativeResponseValue;
22296 // void RevokeAndACK_set_per_commitment_secret(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22298 export function RevokeAndACK_set_per_commitment_secret(this_ptr: number, val: number): void {
22299 if(!isWasmInitialized) {
22300 throw new Error("initializeWasm() must be awaited first!");
22302 const nativeResponseValue = wasm.TS_RevokeAndACK_set_per_commitment_secret(this_ptr, val);
22303 // debug statements here
22305 // struct LDKPublicKey RevokeAndACK_get_next_per_commitment_point(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr);
22307 export function RevokeAndACK_get_next_per_commitment_point(this_ptr: number): number {
22308 if(!isWasmInitialized) {
22309 throw new Error("initializeWasm() must be awaited first!");
22311 const nativeResponseValue = wasm.TS_RevokeAndACK_get_next_per_commitment_point(this_ptr);
22312 return nativeResponseValue;
22314 // void RevokeAndACK_set_next_per_commitment_point(struct LDKRevokeAndACK *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22316 export function RevokeAndACK_set_next_per_commitment_point(this_ptr: number, val: number): void {
22317 if(!isWasmInitialized) {
22318 throw new Error("initializeWasm() must be awaited first!");
22320 const nativeResponseValue = wasm.TS_RevokeAndACK_set_next_per_commitment_point(this_ptr, val);
22321 // debug statements here
22323 // 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);
22325 export function RevokeAndACK_new(channel_id_arg: number, per_commitment_secret_arg: number, next_per_commitment_point_arg: number): number {
22326 if(!isWasmInitialized) {
22327 throw new Error("initializeWasm() must be awaited first!");
22329 const nativeResponseValue = wasm.TS_RevokeAndACK_new(channel_id_arg, per_commitment_secret_arg, next_per_commitment_point_arg);
22330 return nativeResponseValue;
22332 // uintptr_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg);
22334 export function RevokeAndACK_clone_ptr(arg: number): number {
22335 if(!isWasmInitialized) {
22336 throw new Error("initializeWasm() must be awaited first!");
22338 const nativeResponseValue = wasm.TS_RevokeAndACK_clone_ptr(arg);
22339 return nativeResponseValue;
22341 // struct LDKRevokeAndACK RevokeAndACK_clone(const struct LDKRevokeAndACK *NONNULL_PTR orig);
22343 export function RevokeAndACK_clone(orig: number): number {
22344 if(!isWasmInitialized) {
22345 throw new Error("initializeWasm() must be awaited first!");
22347 const nativeResponseValue = wasm.TS_RevokeAndACK_clone(orig);
22348 return nativeResponseValue;
22350 // void UpdateFee_free(struct LDKUpdateFee this_obj);
22352 export function UpdateFee_free(this_obj: number): void {
22353 if(!isWasmInitialized) {
22354 throw new Error("initializeWasm() must be awaited first!");
22356 const nativeResponseValue = wasm.TS_UpdateFee_free(this_obj);
22357 // debug statements here
22359 // const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
22361 export function UpdateFee_get_channel_id(this_ptr: number): number {
22362 if(!isWasmInitialized) {
22363 throw new Error("initializeWasm() must be awaited first!");
22365 const nativeResponseValue = wasm.TS_UpdateFee_get_channel_id(this_ptr);
22366 return nativeResponseValue;
22368 // void UpdateFee_set_channel_id(struct LDKUpdateFee *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22370 export function UpdateFee_set_channel_id(this_ptr: number, val: number): void {
22371 if(!isWasmInitialized) {
22372 throw new Error("initializeWasm() must be awaited first!");
22374 const nativeResponseValue = wasm.TS_UpdateFee_set_channel_id(this_ptr, val);
22375 // debug statements here
22377 // uint32_t UpdateFee_get_feerate_per_kw(const struct LDKUpdateFee *NONNULL_PTR this_ptr);
22379 export function UpdateFee_get_feerate_per_kw(this_ptr: number): number {
22380 if(!isWasmInitialized) {
22381 throw new Error("initializeWasm() must be awaited first!");
22383 const nativeResponseValue = wasm.TS_UpdateFee_get_feerate_per_kw(this_ptr);
22384 return nativeResponseValue;
22386 // void UpdateFee_set_feerate_per_kw(struct LDKUpdateFee *NONNULL_PTR this_ptr, uint32_t val);
22388 export function UpdateFee_set_feerate_per_kw(this_ptr: number, val: number): void {
22389 if(!isWasmInitialized) {
22390 throw new Error("initializeWasm() must be awaited first!");
22392 const nativeResponseValue = wasm.TS_UpdateFee_set_feerate_per_kw(this_ptr, val);
22393 // debug statements here
22395 // MUST_USE_RES struct LDKUpdateFee UpdateFee_new(struct LDKThirtyTwoBytes channel_id_arg, uint32_t feerate_per_kw_arg);
22397 export function UpdateFee_new(channel_id_arg: number, feerate_per_kw_arg: number): number {
22398 if(!isWasmInitialized) {
22399 throw new Error("initializeWasm() must be awaited first!");
22401 const nativeResponseValue = wasm.TS_UpdateFee_new(channel_id_arg, feerate_per_kw_arg);
22402 return nativeResponseValue;
22404 // uintptr_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg);
22406 export function UpdateFee_clone_ptr(arg: number): number {
22407 if(!isWasmInitialized) {
22408 throw new Error("initializeWasm() must be awaited first!");
22410 const nativeResponseValue = wasm.TS_UpdateFee_clone_ptr(arg);
22411 return nativeResponseValue;
22413 // struct LDKUpdateFee UpdateFee_clone(const struct LDKUpdateFee *NONNULL_PTR orig);
22415 export function UpdateFee_clone(orig: number): number {
22416 if(!isWasmInitialized) {
22417 throw new Error("initializeWasm() must be awaited first!");
22419 const nativeResponseValue = wasm.TS_UpdateFee_clone(orig);
22420 return nativeResponseValue;
22422 // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
22424 export function DataLossProtect_free(this_obj: number): void {
22425 if(!isWasmInitialized) {
22426 throw new Error("initializeWasm() must be awaited first!");
22428 const nativeResponseValue = wasm.TS_DataLossProtect_free(this_obj);
22429 // debug statements here
22431 // const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
22433 export function DataLossProtect_get_your_last_per_commitment_secret(this_ptr: number): number {
22434 if(!isWasmInitialized) {
22435 throw new Error("initializeWasm() must be awaited first!");
22437 const nativeResponseValue = wasm.TS_DataLossProtect_get_your_last_per_commitment_secret(this_ptr);
22438 return nativeResponseValue;
22440 // void DataLossProtect_set_your_last_per_commitment_secret(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22442 export function DataLossProtect_set_your_last_per_commitment_secret(this_ptr: number, val: number): void {
22443 if(!isWasmInitialized) {
22444 throw new Error("initializeWasm() must be awaited first!");
22446 const nativeResponseValue = wasm.TS_DataLossProtect_set_your_last_per_commitment_secret(this_ptr, val);
22447 // debug statements here
22449 // struct LDKPublicKey DataLossProtect_get_my_current_per_commitment_point(const struct LDKDataLossProtect *NONNULL_PTR this_ptr);
22451 export function DataLossProtect_get_my_current_per_commitment_point(this_ptr: number): number {
22452 if(!isWasmInitialized) {
22453 throw new Error("initializeWasm() must be awaited first!");
22455 const nativeResponseValue = wasm.TS_DataLossProtect_get_my_current_per_commitment_point(this_ptr);
22456 return nativeResponseValue;
22458 // void DataLossProtect_set_my_current_per_commitment_point(struct LDKDataLossProtect *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22460 export function DataLossProtect_set_my_current_per_commitment_point(this_ptr: number, val: number): void {
22461 if(!isWasmInitialized) {
22462 throw new Error("initializeWasm() must be awaited first!");
22464 const nativeResponseValue = wasm.TS_DataLossProtect_set_my_current_per_commitment_point(this_ptr, val);
22465 // debug statements here
22467 // MUST_USE_RES struct LDKDataLossProtect DataLossProtect_new(struct LDKThirtyTwoBytes your_last_per_commitment_secret_arg, struct LDKPublicKey my_current_per_commitment_point_arg);
22469 export function DataLossProtect_new(your_last_per_commitment_secret_arg: number, my_current_per_commitment_point_arg: number): number {
22470 if(!isWasmInitialized) {
22471 throw new Error("initializeWasm() must be awaited first!");
22473 const nativeResponseValue = wasm.TS_DataLossProtect_new(your_last_per_commitment_secret_arg, my_current_per_commitment_point_arg);
22474 return nativeResponseValue;
22476 // uintptr_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg);
22478 export function DataLossProtect_clone_ptr(arg: number): number {
22479 if(!isWasmInitialized) {
22480 throw new Error("initializeWasm() must be awaited first!");
22482 const nativeResponseValue = wasm.TS_DataLossProtect_clone_ptr(arg);
22483 return nativeResponseValue;
22485 // struct LDKDataLossProtect DataLossProtect_clone(const struct LDKDataLossProtect *NONNULL_PTR orig);
22487 export function DataLossProtect_clone(orig: number): number {
22488 if(!isWasmInitialized) {
22489 throw new Error("initializeWasm() must be awaited first!");
22491 const nativeResponseValue = wasm.TS_DataLossProtect_clone(orig);
22492 return nativeResponseValue;
22494 // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
22496 export function ChannelReestablish_free(this_obj: number): void {
22497 if(!isWasmInitialized) {
22498 throw new Error("initializeWasm() must be awaited first!");
22500 const nativeResponseValue = wasm.TS_ChannelReestablish_free(this_obj);
22501 // debug statements here
22503 // const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
22505 export function ChannelReestablish_get_channel_id(this_ptr: number): number {
22506 if(!isWasmInitialized) {
22507 throw new Error("initializeWasm() must be awaited first!");
22509 const nativeResponseValue = wasm.TS_ChannelReestablish_get_channel_id(this_ptr);
22510 return nativeResponseValue;
22512 // void ChannelReestablish_set_channel_id(struct LDKChannelReestablish *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22514 export function ChannelReestablish_set_channel_id(this_ptr: number, val: number): void {
22515 if(!isWasmInitialized) {
22516 throw new Error("initializeWasm() must be awaited first!");
22518 const nativeResponseValue = wasm.TS_ChannelReestablish_set_channel_id(this_ptr, val);
22519 // debug statements here
22521 // uint64_t ChannelReestablish_get_next_local_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
22523 export function ChannelReestablish_get_next_local_commitment_number(this_ptr: number): bigint {
22524 if(!isWasmInitialized) {
22525 throw new Error("initializeWasm() must be awaited first!");
22527 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_local_commitment_number(this_ptr);
22528 return nativeResponseValue;
22530 // void ChannelReestablish_set_next_local_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
22532 export function ChannelReestablish_set_next_local_commitment_number(this_ptr: number, val: bigint): void {
22533 if(!isWasmInitialized) {
22534 throw new Error("initializeWasm() must be awaited first!");
22536 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_local_commitment_number(this_ptr, val);
22537 // debug statements here
22539 // uint64_t ChannelReestablish_get_next_remote_commitment_number(const struct LDKChannelReestablish *NONNULL_PTR this_ptr);
22541 export function ChannelReestablish_get_next_remote_commitment_number(this_ptr: number): bigint {
22542 if(!isWasmInitialized) {
22543 throw new Error("initializeWasm() must be awaited first!");
22545 const nativeResponseValue = wasm.TS_ChannelReestablish_get_next_remote_commitment_number(this_ptr);
22546 return nativeResponseValue;
22548 // void ChannelReestablish_set_next_remote_commitment_number(struct LDKChannelReestablish *NONNULL_PTR this_ptr, uint64_t val);
22550 export function ChannelReestablish_set_next_remote_commitment_number(this_ptr: number, val: bigint): void {
22551 if(!isWasmInitialized) {
22552 throw new Error("initializeWasm() must be awaited first!");
22554 const nativeResponseValue = wasm.TS_ChannelReestablish_set_next_remote_commitment_number(this_ptr, val);
22555 // debug statements here
22557 // uintptr_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg);
22559 export function ChannelReestablish_clone_ptr(arg: number): number {
22560 if(!isWasmInitialized) {
22561 throw new Error("initializeWasm() must be awaited first!");
22563 const nativeResponseValue = wasm.TS_ChannelReestablish_clone_ptr(arg);
22564 return nativeResponseValue;
22566 // struct LDKChannelReestablish ChannelReestablish_clone(const struct LDKChannelReestablish *NONNULL_PTR orig);
22568 export function ChannelReestablish_clone(orig: number): number {
22569 if(!isWasmInitialized) {
22570 throw new Error("initializeWasm() must be awaited first!");
22572 const nativeResponseValue = wasm.TS_ChannelReestablish_clone(orig);
22573 return nativeResponseValue;
22575 // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
22577 export function AnnouncementSignatures_free(this_obj: number): void {
22578 if(!isWasmInitialized) {
22579 throw new Error("initializeWasm() must be awaited first!");
22581 const nativeResponseValue = wasm.TS_AnnouncementSignatures_free(this_obj);
22582 // debug statements here
22584 // const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
22586 export function AnnouncementSignatures_get_channel_id(this_ptr: number): number {
22587 if(!isWasmInitialized) {
22588 throw new Error("initializeWasm() must be awaited first!");
22590 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_channel_id(this_ptr);
22591 return nativeResponseValue;
22593 // void AnnouncementSignatures_set_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22595 export function AnnouncementSignatures_set_channel_id(this_ptr: number, val: number): void {
22596 if(!isWasmInitialized) {
22597 throw new Error("initializeWasm() must be awaited first!");
22599 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_channel_id(this_ptr, val);
22600 // debug statements here
22602 // uint64_t AnnouncementSignatures_get_short_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
22604 export function AnnouncementSignatures_get_short_channel_id(this_ptr: number): bigint {
22605 if(!isWasmInitialized) {
22606 throw new Error("initializeWasm() must be awaited first!");
22608 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_short_channel_id(this_ptr);
22609 return nativeResponseValue;
22611 // void AnnouncementSignatures_set_short_channel_id(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, uint64_t val);
22613 export function AnnouncementSignatures_set_short_channel_id(this_ptr: number, val: bigint): void {
22614 if(!isWasmInitialized) {
22615 throw new Error("initializeWasm() must be awaited first!");
22617 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_short_channel_id(this_ptr, val);
22618 // debug statements here
22620 // struct LDKSignature AnnouncementSignatures_get_node_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
22622 export function AnnouncementSignatures_get_node_signature(this_ptr: number): number {
22623 if(!isWasmInitialized) {
22624 throw new Error("initializeWasm() must be awaited first!");
22626 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_node_signature(this_ptr);
22627 return nativeResponseValue;
22629 // void AnnouncementSignatures_set_node_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
22631 export function AnnouncementSignatures_set_node_signature(this_ptr: number, val: number): void {
22632 if(!isWasmInitialized) {
22633 throw new Error("initializeWasm() must be awaited first!");
22635 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_node_signature(this_ptr, val);
22636 // debug statements here
22638 // struct LDKSignature AnnouncementSignatures_get_bitcoin_signature(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr);
22640 export function AnnouncementSignatures_get_bitcoin_signature(this_ptr: number): number {
22641 if(!isWasmInitialized) {
22642 throw new Error("initializeWasm() must be awaited first!");
22644 const nativeResponseValue = wasm.TS_AnnouncementSignatures_get_bitcoin_signature(this_ptr);
22645 return nativeResponseValue;
22647 // void AnnouncementSignatures_set_bitcoin_signature(struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr, struct LDKSignature val);
22649 export function AnnouncementSignatures_set_bitcoin_signature(this_ptr: number, val: number): void {
22650 if(!isWasmInitialized) {
22651 throw new Error("initializeWasm() must be awaited first!");
22653 const nativeResponseValue = wasm.TS_AnnouncementSignatures_set_bitcoin_signature(this_ptr, val);
22654 // debug statements here
22656 // 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);
22658 export function AnnouncementSignatures_new(channel_id_arg: number, short_channel_id_arg: bigint, node_signature_arg: number, bitcoin_signature_arg: number): number {
22659 if(!isWasmInitialized) {
22660 throw new Error("initializeWasm() must be awaited first!");
22662 const nativeResponseValue = wasm.TS_AnnouncementSignatures_new(channel_id_arg, short_channel_id_arg, node_signature_arg, bitcoin_signature_arg);
22663 return nativeResponseValue;
22665 // uintptr_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg);
22667 export function AnnouncementSignatures_clone_ptr(arg: number): number {
22668 if(!isWasmInitialized) {
22669 throw new Error("initializeWasm() must be awaited first!");
22671 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone_ptr(arg);
22672 return nativeResponseValue;
22674 // struct LDKAnnouncementSignatures AnnouncementSignatures_clone(const struct LDKAnnouncementSignatures *NONNULL_PTR orig);
22676 export function AnnouncementSignatures_clone(orig: number): number {
22677 if(!isWasmInitialized) {
22678 throw new Error("initializeWasm() must be awaited first!");
22680 const nativeResponseValue = wasm.TS_AnnouncementSignatures_clone(orig);
22681 return nativeResponseValue;
22683 // void NetAddress_free(struct LDKNetAddress this_ptr);
22685 export function NetAddress_free(this_ptr: number): void {
22686 if(!isWasmInitialized) {
22687 throw new Error("initializeWasm() must be awaited first!");
22689 const nativeResponseValue = wasm.TS_NetAddress_free(this_ptr);
22690 // debug statements here
22692 // uintptr_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg);
22694 export function NetAddress_clone_ptr(arg: number): number {
22695 if(!isWasmInitialized) {
22696 throw new Error("initializeWasm() must be awaited first!");
22698 const nativeResponseValue = wasm.TS_NetAddress_clone_ptr(arg);
22699 return nativeResponseValue;
22701 // struct LDKNetAddress NetAddress_clone(const struct LDKNetAddress *NONNULL_PTR orig);
22703 export function NetAddress_clone(orig: number): number {
22704 if(!isWasmInitialized) {
22705 throw new Error("initializeWasm() must be awaited first!");
22707 const nativeResponseValue = wasm.TS_NetAddress_clone(orig);
22708 return nativeResponseValue;
22710 // struct LDKNetAddress NetAddress_ipv4(struct LDKFourBytes addr, uint16_t port);
22712 export function NetAddress_ipv4(addr: number, port: number): number {
22713 if(!isWasmInitialized) {
22714 throw new Error("initializeWasm() must be awaited first!");
22716 const nativeResponseValue = wasm.TS_NetAddress_ipv4(addr, port);
22717 return nativeResponseValue;
22719 // struct LDKNetAddress NetAddress_ipv6(struct LDKSixteenBytes addr, uint16_t port);
22721 export function NetAddress_ipv6(addr: number, port: number): number {
22722 if(!isWasmInitialized) {
22723 throw new Error("initializeWasm() must be awaited first!");
22725 const nativeResponseValue = wasm.TS_NetAddress_ipv6(addr, port);
22726 return nativeResponseValue;
22728 // struct LDKNetAddress NetAddress_onion_v2(struct LDKTwelveBytes a);
22730 export function NetAddress_onion_v2(a: number): number {
22731 if(!isWasmInitialized) {
22732 throw new Error("initializeWasm() must be awaited first!");
22734 const nativeResponseValue = wasm.TS_NetAddress_onion_v2(a);
22735 return nativeResponseValue;
22737 // struct LDKNetAddress NetAddress_onion_v3(struct LDKThirtyTwoBytes ed25519_pubkey, uint16_t checksum, uint8_t version, uint16_t port);
22739 export function NetAddress_onion_v3(ed25519_pubkey: number, checksum: number, version: number, port: number): number {
22740 if(!isWasmInitialized) {
22741 throw new Error("initializeWasm() must be awaited first!");
22743 const nativeResponseValue = wasm.TS_NetAddress_onion_v3(ed25519_pubkey, checksum, version, port);
22744 return nativeResponseValue;
22746 // struct LDKCVec_u8Z NetAddress_write(const struct LDKNetAddress *NONNULL_PTR obj);
22748 export function NetAddress_write(obj: number): number {
22749 if(!isWasmInitialized) {
22750 throw new Error("initializeWasm() must be awaited first!");
22752 const nativeResponseValue = wasm.TS_NetAddress_write(obj);
22753 return nativeResponseValue;
22755 // struct LDKCResult_NetAddressDecodeErrorZ NetAddress_read(struct LDKu8slice ser);
22757 export function NetAddress_read(ser: number): number {
22758 if(!isWasmInitialized) {
22759 throw new Error("initializeWasm() must be awaited first!");
22761 const nativeResponseValue = wasm.TS_NetAddress_read(ser);
22762 return nativeResponseValue;
22764 // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
22766 export function UnsignedNodeAnnouncement_free(this_obj: number): void {
22767 if(!isWasmInitialized) {
22768 throw new Error("initializeWasm() must be awaited first!");
22770 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_free(this_obj);
22771 // debug statements here
22773 // struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
22775 export function UnsignedNodeAnnouncement_get_features(this_ptr: number): number {
22776 if(!isWasmInitialized) {
22777 throw new Error("initializeWasm() must be awaited first!");
22779 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_features(this_ptr);
22780 return nativeResponseValue;
22782 // void UnsignedNodeAnnouncement_set_features(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
22784 export function UnsignedNodeAnnouncement_set_features(this_ptr: number, val: number): void {
22785 if(!isWasmInitialized) {
22786 throw new Error("initializeWasm() must be awaited first!");
22788 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_features(this_ptr, val);
22789 // debug statements here
22791 // uint32_t UnsignedNodeAnnouncement_get_timestamp(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
22793 export function UnsignedNodeAnnouncement_get_timestamp(this_ptr: number): number {
22794 if(!isWasmInitialized) {
22795 throw new Error("initializeWasm() must be awaited first!");
22797 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_timestamp(this_ptr);
22798 return nativeResponseValue;
22800 // void UnsignedNodeAnnouncement_set_timestamp(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, uint32_t val);
22802 export function UnsignedNodeAnnouncement_set_timestamp(this_ptr: number, val: number): void {
22803 if(!isWasmInitialized) {
22804 throw new Error("initializeWasm() must be awaited first!");
22806 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_timestamp(this_ptr, val);
22807 // debug statements here
22809 // struct LDKPublicKey UnsignedNodeAnnouncement_get_node_id(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
22811 export function UnsignedNodeAnnouncement_get_node_id(this_ptr: number): number {
22812 if(!isWasmInitialized) {
22813 throw new Error("initializeWasm() must be awaited first!");
22815 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_node_id(this_ptr);
22816 return nativeResponseValue;
22818 // void UnsignedNodeAnnouncement_set_node_id(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
22820 export function UnsignedNodeAnnouncement_set_node_id(this_ptr: number, val: number): void {
22821 if(!isWasmInitialized) {
22822 throw new Error("initializeWasm() must be awaited first!");
22824 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_node_id(this_ptr, val);
22825 // debug statements here
22827 // const uint8_t (*UnsignedNodeAnnouncement_get_rgb(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[3];
22829 export function UnsignedNodeAnnouncement_get_rgb(this_ptr: number): number {
22830 if(!isWasmInitialized) {
22831 throw new Error("initializeWasm() must be awaited first!");
22833 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_rgb(this_ptr);
22834 return nativeResponseValue;
22836 // void UnsignedNodeAnnouncement_set_rgb(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
22838 export function UnsignedNodeAnnouncement_set_rgb(this_ptr: number, val: number): void {
22839 if(!isWasmInitialized) {
22840 throw new Error("initializeWasm() must be awaited first!");
22842 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_rgb(this_ptr, val);
22843 // debug statements here
22845 // const uint8_t (*UnsignedNodeAnnouncement_get_alias(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr))[32];
22847 export function UnsignedNodeAnnouncement_get_alias(this_ptr: number): number {
22848 if(!isWasmInitialized) {
22849 throw new Error("initializeWasm() must be awaited first!");
22851 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_get_alias(this_ptr);
22852 return nativeResponseValue;
22854 // void UnsignedNodeAnnouncement_set_alias(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
22856 export function UnsignedNodeAnnouncement_set_alias(this_ptr: number, val: number): void {
22857 if(!isWasmInitialized) {
22858 throw new Error("initializeWasm() must be awaited first!");
22860 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_alias(this_ptr, val);
22861 // debug statements here
22863 // void UnsignedNodeAnnouncement_set_addresses(struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
22865 export function UnsignedNodeAnnouncement_set_addresses(this_ptr: number, val: number): void {
22866 if(!isWasmInitialized) {
22867 throw new Error("initializeWasm() must be awaited first!");
22869 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_set_addresses(this_ptr, val);
22870 // debug statements here
22872 // uintptr_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg);
22874 export function UnsignedNodeAnnouncement_clone_ptr(arg: number): number {
22875 if(!isWasmInitialized) {
22876 throw new Error("initializeWasm() must be awaited first!");
22878 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone_ptr(arg);
22879 return nativeResponseValue;
22881 // struct LDKUnsignedNodeAnnouncement UnsignedNodeAnnouncement_clone(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR orig);
22883 export function UnsignedNodeAnnouncement_clone(orig: number): number {
22884 if(!isWasmInitialized) {
22885 throw new Error("initializeWasm() must be awaited first!");
22887 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_clone(orig);
22888 return nativeResponseValue;
22890 // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
22892 export function NodeAnnouncement_free(this_obj: number): void {
22893 if(!isWasmInitialized) {
22894 throw new Error("initializeWasm() must be awaited first!");
22896 const nativeResponseValue = wasm.TS_NodeAnnouncement_free(this_obj);
22897 // debug statements here
22899 // struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
22901 export function NodeAnnouncement_get_signature(this_ptr: number): number {
22902 if(!isWasmInitialized) {
22903 throw new Error("initializeWasm() must be awaited first!");
22905 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_signature(this_ptr);
22906 return nativeResponseValue;
22908 // void NodeAnnouncement_set_signature(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
22910 export function NodeAnnouncement_set_signature(this_ptr: number, val: number): void {
22911 if(!isWasmInitialized) {
22912 throw new Error("initializeWasm() must be awaited first!");
22914 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_signature(this_ptr, val);
22915 // debug statements here
22917 // struct LDKUnsignedNodeAnnouncement NodeAnnouncement_get_contents(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
22919 export function NodeAnnouncement_get_contents(this_ptr: number): number {
22920 if(!isWasmInitialized) {
22921 throw new Error("initializeWasm() must be awaited first!");
22923 const nativeResponseValue = wasm.TS_NodeAnnouncement_get_contents(this_ptr);
22924 return nativeResponseValue;
22926 // void NodeAnnouncement_set_contents(struct LDKNodeAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedNodeAnnouncement val);
22928 export function NodeAnnouncement_set_contents(this_ptr: number, val: number): void {
22929 if(!isWasmInitialized) {
22930 throw new Error("initializeWasm() must be awaited first!");
22932 const nativeResponseValue = wasm.TS_NodeAnnouncement_set_contents(this_ptr, val);
22933 // debug statements here
22935 // MUST_USE_RES struct LDKNodeAnnouncement NodeAnnouncement_new(struct LDKSignature signature_arg, struct LDKUnsignedNodeAnnouncement contents_arg);
22937 export function NodeAnnouncement_new(signature_arg: number, contents_arg: number): number {
22938 if(!isWasmInitialized) {
22939 throw new Error("initializeWasm() must be awaited first!");
22941 const nativeResponseValue = wasm.TS_NodeAnnouncement_new(signature_arg, contents_arg);
22942 return nativeResponseValue;
22944 // uintptr_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg);
22946 export function NodeAnnouncement_clone_ptr(arg: number): number {
22947 if(!isWasmInitialized) {
22948 throw new Error("initializeWasm() must be awaited first!");
22950 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone_ptr(arg);
22951 return nativeResponseValue;
22953 // struct LDKNodeAnnouncement NodeAnnouncement_clone(const struct LDKNodeAnnouncement *NONNULL_PTR orig);
22955 export function NodeAnnouncement_clone(orig: number): number {
22956 if(!isWasmInitialized) {
22957 throw new Error("initializeWasm() must be awaited first!");
22959 const nativeResponseValue = wasm.TS_NodeAnnouncement_clone(orig);
22960 return nativeResponseValue;
22962 // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
22964 export function UnsignedChannelAnnouncement_free(this_obj: number): void {
22965 if(!isWasmInitialized) {
22966 throw new Error("initializeWasm() must be awaited first!");
22968 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_free(this_obj);
22969 // debug statements here
22971 // struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
22973 export function UnsignedChannelAnnouncement_get_features(this_ptr: number): number {
22974 if(!isWasmInitialized) {
22975 throw new Error("initializeWasm() must be awaited first!");
22977 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_features(this_ptr);
22978 return nativeResponseValue;
22980 // void UnsignedChannelAnnouncement_set_features(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
22982 export function UnsignedChannelAnnouncement_set_features(this_ptr: number, val: number): void {
22983 if(!isWasmInitialized) {
22984 throw new Error("initializeWasm() must be awaited first!");
22986 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_features(this_ptr, val);
22987 // debug statements here
22989 // const uint8_t (*UnsignedChannelAnnouncement_get_chain_hash(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr))[32];
22991 export function UnsignedChannelAnnouncement_get_chain_hash(this_ptr: number): number {
22992 if(!isWasmInitialized) {
22993 throw new Error("initializeWasm() must be awaited first!");
22995 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_chain_hash(this_ptr);
22996 return nativeResponseValue;
22998 // void UnsignedChannelAnnouncement_set_chain_hash(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23000 export function UnsignedChannelAnnouncement_set_chain_hash(this_ptr: number, val: number): void {
23001 if(!isWasmInitialized) {
23002 throw new Error("initializeWasm() must be awaited first!");
23004 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_chain_hash(this_ptr, val);
23005 // debug statements here
23007 // uint64_t UnsignedChannelAnnouncement_get_short_channel_id(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23009 export function UnsignedChannelAnnouncement_get_short_channel_id(this_ptr: number): bigint {
23010 if(!isWasmInitialized) {
23011 throw new Error("initializeWasm() must be awaited first!");
23013 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_short_channel_id(this_ptr);
23014 return nativeResponseValue;
23016 // void UnsignedChannelAnnouncement_set_short_channel_id(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, uint64_t val);
23018 export function UnsignedChannelAnnouncement_set_short_channel_id(this_ptr: number, val: bigint): void {
23019 if(!isWasmInitialized) {
23020 throw new Error("initializeWasm() must be awaited first!");
23022 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_short_channel_id(this_ptr, val);
23023 // debug statements here
23025 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23027 export function UnsignedChannelAnnouncement_get_node_id_1(this_ptr: number): number {
23028 if(!isWasmInitialized) {
23029 throw new Error("initializeWasm() must be awaited first!");
23031 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_1(this_ptr);
23032 return nativeResponseValue;
23034 // void UnsignedChannelAnnouncement_set_node_id_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23036 export function UnsignedChannelAnnouncement_set_node_id_1(this_ptr: number, val: number): void {
23037 if(!isWasmInitialized) {
23038 throw new Error("initializeWasm() must be awaited first!");
23040 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_1(this_ptr, val);
23041 // debug statements here
23043 // struct LDKPublicKey UnsignedChannelAnnouncement_get_node_id_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23045 export function UnsignedChannelAnnouncement_get_node_id_2(this_ptr: number): number {
23046 if(!isWasmInitialized) {
23047 throw new Error("initializeWasm() must be awaited first!");
23049 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_node_id_2(this_ptr);
23050 return nativeResponseValue;
23052 // void UnsignedChannelAnnouncement_set_node_id_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23054 export function UnsignedChannelAnnouncement_set_node_id_2(this_ptr: number, val: number): void {
23055 if(!isWasmInitialized) {
23056 throw new Error("initializeWasm() must be awaited first!");
23058 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_node_id_2(this_ptr, val);
23059 // debug statements here
23061 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_1(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23063 export function UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr: number): number {
23064 if(!isWasmInitialized) {
23065 throw new Error("initializeWasm() must be awaited first!");
23067 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(this_ptr);
23068 return nativeResponseValue;
23070 // void UnsignedChannelAnnouncement_set_bitcoin_key_1(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23072 export function UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr: number, val: number): void {
23073 if(!isWasmInitialized) {
23074 throw new Error("initializeWasm() must be awaited first!");
23076 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(this_ptr, val);
23077 // debug statements here
23079 // struct LDKPublicKey UnsignedChannelAnnouncement_get_bitcoin_key_2(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
23081 export function UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr: number): number {
23082 if(!isWasmInitialized) {
23083 throw new Error("initializeWasm() must be awaited first!");
23085 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(this_ptr);
23086 return nativeResponseValue;
23088 // void UnsignedChannelAnnouncement_set_bitcoin_key_2(struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKPublicKey val);
23090 export function UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr: number, val: number): void {
23091 if(!isWasmInitialized) {
23092 throw new Error("initializeWasm() must be awaited first!");
23094 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(this_ptr, val);
23095 // debug statements here
23097 // uintptr_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg);
23099 export function UnsignedChannelAnnouncement_clone_ptr(arg: number): number {
23100 if(!isWasmInitialized) {
23101 throw new Error("initializeWasm() must be awaited first!");
23103 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone_ptr(arg);
23104 return nativeResponseValue;
23106 // struct LDKUnsignedChannelAnnouncement UnsignedChannelAnnouncement_clone(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR orig);
23108 export function UnsignedChannelAnnouncement_clone(orig: number): number {
23109 if(!isWasmInitialized) {
23110 throw new Error("initializeWasm() must be awaited first!");
23112 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_clone(orig);
23113 return nativeResponseValue;
23115 // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
23117 export function ChannelAnnouncement_free(this_obj: number): void {
23118 if(!isWasmInitialized) {
23119 throw new Error("initializeWasm() must be awaited first!");
23121 const nativeResponseValue = wasm.TS_ChannelAnnouncement_free(this_obj);
23122 // debug statements here
23124 // struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23126 export function ChannelAnnouncement_get_node_signature_1(this_ptr: number): number {
23127 if(!isWasmInitialized) {
23128 throw new Error("initializeWasm() must be awaited first!");
23130 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_1(this_ptr);
23131 return nativeResponseValue;
23133 // void ChannelAnnouncement_set_node_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23135 export function ChannelAnnouncement_set_node_signature_1(this_ptr: number, val: number): void {
23136 if(!isWasmInitialized) {
23137 throw new Error("initializeWasm() must be awaited first!");
23139 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_1(this_ptr, val);
23140 // debug statements here
23142 // struct LDKSignature ChannelAnnouncement_get_node_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23144 export function ChannelAnnouncement_get_node_signature_2(this_ptr: number): number {
23145 if(!isWasmInitialized) {
23146 throw new Error("initializeWasm() must be awaited first!");
23148 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_node_signature_2(this_ptr);
23149 return nativeResponseValue;
23151 // void ChannelAnnouncement_set_node_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23153 export function ChannelAnnouncement_set_node_signature_2(this_ptr: number, val: number): void {
23154 if(!isWasmInitialized) {
23155 throw new Error("initializeWasm() must be awaited first!");
23157 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_node_signature_2(this_ptr, val);
23158 // debug statements here
23160 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23162 export function ChannelAnnouncement_get_bitcoin_signature_1(this_ptr: number): number {
23163 if(!isWasmInitialized) {
23164 throw new Error("initializeWasm() must be awaited first!");
23166 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_1(this_ptr);
23167 return nativeResponseValue;
23169 // void ChannelAnnouncement_set_bitcoin_signature_1(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23171 export function ChannelAnnouncement_set_bitcoin_signature_1(this_ptr: number, val: number): void {
23172 if(!isWasmInitialized) {
23173 throw new Error("initializeWasm() must be awaited first!");
23175 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_1(this_ptr, val);
23176 // debug statements here
23178 // struct LDKSignature ChannelAnnouncement_get_bitcoin_signature_2(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23180 export function ChannelAnnouncement_get_bitcoin_signature_2(this_ptr: number): number {
23181 if(!isWasmInitialized) {
23182 throw new Error("initializeWasm() must be awaited first!");
23184 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_bitcoin_signature_2(this_ptr);
23185 return nativeResponseValue;
23187 // void ChannelAnnouncement_set_bitcoin_signature_2(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKSignature val);
23189 export function ChannelAnnouncement_set_bitcoin_signature_2(this_ptr: number, val: number): void {
23190 if(!isWasmInitialized) {
23191 throw new Error("initializeWasm() must be awaited first!");
23193 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_bitcoin_signature_2(this_ptr, val);
23194 // debug statements here
23196 // struct LDKUnsignedChannelAnnouncement ChannelAnnouncement_get_contents(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
23198 export function ChannelAnnouncement_get_contents(this_ptr: number): number {
23199 if(!isWasmInitialized) {
23200 throw new Error("initializeWasm() must be awaited first!");
23202 const nativeResponseValue = wasm.TS_ChannelAnnouncement_get_contents(this_ptr);
23203 return nativeResponseValue;
23205 // void ChannelAnnouncement_set_contents(struct LDKChannelAnnouncement *NONNULL_PTR this_ptr, struct LDKUnsignedChannelAnnouncement val);
23207 export function ChannelAnnouncement_set_contents(this_ptr: number, val: number): void {
23208 if(!isWasmInitialized) {
23209 throw new Error("initializeWasm() must be awaited first!");
23211 const nativeResponseValue = wasm.TS_ChannelAnnouncement_set_contents(this_ptr, val);
23212 // debug statements here
23214 // 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);
23216 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 {
23217 if(!isWasmInitialized) {
23218 throw new Error("initializeWasm() must be awaited first!");
23220 const nativeResponseValue = wasm.TS_ChannelAnnouncement_new(node_signature_1_arg, node_signature_2_arg, bitcoin_signature_1_arg, bitcoin_signature_2_arg, contents_arg);
23221 return nativeResponseValue;
23223 // uintptr_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg);
23225 export function ChannelAnnouncement_clone_ptr(arg: number): number {
23226 if(!isWasmInitialized) {
23227 throw new Error("initializeWasm() must be awaited first!");
23229 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone_ptr(arg);
23230 return nativeResponseValue;
23232 // struct LDKChannelAnnouncement ChannelAnnouncement_clone(const struct LDKChannelAnnouncement *NONNULL_PTR orig);
23234 export function ChannelAnnouncement_clone(orig: number): number {
23235 if(!isWasmInitialized) {
23236 throw new Error("initializeWasm() must be awaited first!");
23238 const nativeResponseValue = wasm.TS_ChannelAnnouncement_clone(orig);
23239 return nativeResponseValue;
23241 // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
23243 export function UnsignedChannelUpdate_free(this_obj: number): void {
23244 if(!isWasmInitialized) {
23245 throw new Error("initializeWasm() must be awaited first!");
23247 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_free(this_obj);
23248 // debug statements here
23250 // const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
23252 export function UnsignedChannelUpdate_get_chain_hash(this_ptr: number): number {
23253 if(!isWasmInitialized) {
23254 throw new Error("initializeWasm() must be awaited first!");
23256 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_chain_hash(this_ptr);
23257 return nativeResponseValue;
23259 // void UnsignedChannelUpdate_set_chain_hash(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23261 export function UnsignedChannelUpdate_set_chain_hash(this_ptr: number, val: number): void {
23262 if(!isWasmInitialized) {
23263 throw new Error("initializeWasm() must be awaited first!");
23265 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_chain_hash(this_ptr, val);
23266 // debug statements here
23268 // uint64_t UnsignedChannelUpdate_get_short_channel_id(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23270 export function UnsignedChannelUpdate_get_short_channel_id(this_ptr: number): bigint {
23271 if(!isWasmInitialized) {
23272 throw new Error("initializeWasm() must be awaited first!");
23274 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_short_channel_id(this_ptr);
23275 return nativeResponseValue;
23277 // void UnsignedChannelUpdate_set_short_channel_id(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23279 export function UnsignedChannelUpdate_set_short_channel_id(this_ptr: number, val: bigint): void {
23280 if(!isWasmInitialized) {
23281 throw new Error("initializeWasm() must be awaited first!");
23283 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_short_channel_id(this_ptr, val);
23284 // debug statements here
23286 // uint32_t UnsignedChannelUpdate_get_timestamp(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23288 export function UnsignedChannelUpdate_get_timestamp(this_ptr: number): number {
23289 if(!isWasmInitialized) {
23290 throw new Error("initializeWasm() must be awaited first!");
23292 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_timestamp(this_ptr);
23293 return nativeResponseValue;
23295 // void UnsignedChannelUpdate_set_timestamp(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23297 export function UnsignedChannelUpdate_set_timestamp(this_ptr: number, val: number): void {
23298 if(!isWasmInitialized) {
23299 throw new Error("initializeWasm() must be awaited first!");
23301 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_timestamp(this_ptr, val);
23302 // debug statements here
23304 // uint8_t UnsignedChannelUpdate_get_flags(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23306 export function UnsignedChannelUpdate_get_flags(this_ptr: number): number {
23307 if(!isWasmInitialized) {
23308 throw new Error("initializeWasm() must be awaited first!");
23310 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_flags(this_ptr);
23311 return nativeResponseValue;
23313 // void UnsignedChannelUpdate_set_flags(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint8_t val);
23315 export function UnsignedChannelUpdate_set_flags(this_ptr: number, val: number): void {
23316 if(!isWasmInitialized) {
23317 throw new Error("initializeWasm() must be awaited first!");
23319 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_flags(this_ptr, val);
23320 // debug statements here
23322 // uint16_t UnsignedChannelUpdate_get_cltv_expiry_delta(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23324 export function UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr: number): number {
23325 if(!isWasmInitialized) {
23326 throw new Error("initializeWasm() must be awaited first!");
23328 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_cltv_expiry_delta(this_ptr);
23329 return nativeResponseValue;
23331 // void UnsignedChannelUpdate_set_cltv_expiry_delta(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint16_t val);
23333 export function UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr: number, val: number): void {
23334 if(!isWasmInitialized) {
23335 throw new Error("initializeWasm() must be awaited first!");
23337 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_cltv_expiry_delta(this_ptr, val);
23338 // debug statements here
23340 // uint64_t UnsignedChannelUpdate_get_htlc_minimum_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23342 export function UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr: number): bigint {
23343 if(!isWasmInitialized) {
23344 throw new Error("initializeWasm() must be awaited first!");
23346 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_htlc_minimum_msat(this_ptr);
23347 return nativeResponseValue;
23349 // void UnsignedChannelUpdate_set_htlc_minimum_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint64_t val);
23351 export function UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
23352 if(!isWasmInitialized) {
23353 throw new Error("initializeWasm() must be awaited first!");
23355 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_htlc_minimum_msat(this_ptr, val);
23356 // debug statements here
23358 // uint32_t UnsignedChannelUpdate_get_fee_base_msat(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23360 export function UnsignedChannelUpdate_get_fee_base_msat(this_ptr: number): number {
23361 if(!isWasmInitialized) {
23362 throw new Error("initializeWasm() must be awaited first!");
23364 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_base_msat(this_ptr);
23365 return nativeResponseValue;
23367 // void UnsignedChannelUpdate_set_fee_base_msat(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23369 export function UnsignedChannelUpdate_set_fee_base_msat(this_ptr: number, val: number): void {
23370 if(!isWasmInitialized) {
23371 throw new Error("initializeWasm() must be awaited first!");
23373 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_base_msat(this_ptr, val);
23374 // debug statements here
23376 // uint32_t UnsignedChannelUpdate_get_fee_proportional_millionths(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr);
23378 export function UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr: number): number {
23379 if(!isWasmInitialized) {
23380 throw new Error("initializeWasm() must be awaited first!");
23382 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_get_fee_proportional_millionths(this_ptr);
23383 return nativeResponseValue;
23385 // void UnsignedChannelUpdate_set_fee_proportional_millionths(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, uint32_t val);
23387 export function UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr: number, val: number): void {
23388 if(!isWasmInitialized) {
23389 throw new Error("initializeWasm() must be awaited first!");
23391 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_fee_proportional_millionths(this_ptr, val);
23392 // debug statements here
23394 // void UnsignedChannelUpdate_set_excess_data(struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
23396 export function UnsignedChannelUpdate_set_excess_data(this_ptr: number, val: number): void {
23397 if(!isWasmInitialized) {
23398 throw new Error("initializeWasm() must be awaited first!");
23400 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_set_excess_data(this_ptr, val);
23401 // debug statements here
23403 // uintptr_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg);
23405 export function UnsignedChannelUpdate_clone_ptr(arg: number): number {
23406 if(!isWasmInitialized) {
23407 throw new Error("initializeWasm() must be awaited first!");
23409 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone_ptr(arg);
23410 return nativeResponseValue;
23412 // struct LDKUnsignedChannelUpdate UnsignedChannelUpdate_clone(const struct LDKUnsignedChannelUpdate *NONNULL_PTR orig);
23414 export function UnsignedChannelUpdate_clone(orig: number): number {
23415 if(!isWasmInitialized) {
23416 throw new Error("initializeWasm() must be awaited first!");
23418 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_clone(orig);
23419 return nativeResponseValue;
23421 // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
23423 export function ChannelUpdate_free(this_obj: number): void {
23424 if(!isWasmInitialized) {
23425 throw new Error("initializeWasm() must be awaited first!");
23427 const nativeResponseValue = wasm.TS_ChannelUpdate_free(this_obj);
23428 // debug statements here
23430 // struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
23432 export function ChannelUpdate_get_signature(this_ptr: number): number {
23433 if(!isWasmInitialized) {
23434 throw new Error("initializeWasm() must be awaited first!");
23436 const nativeResponseValue = wasm.TS_ChannelUpdate_get_signature(this_ptr);
23437 return nativeResponseValue;
23439 // void ChannelUpdate_set_signature(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKSignature val);
23441 export function ChannelUpdate_set_signature(this_ptr: number, val: number): void {
23442 if(!isWasmInitialized) {
23443 throw new Error("initializeWasm() must be awaited first!");
23445 const nativeResponseValue = wasm.TS_ChannelUpdate_set_signature(this_ptr, val);
23446 // debug statements here
23448 // struct LDKUnsignedChannelUpdate ChannelUpdate_get_contents(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
23450 export function ChannelUpdate_get_contents(this_ptr: number): number {
23451 if(!isWasmInitialized) {
23452 throw new Error("initializeWasm() must be awaited first!");
23454 const nativeResponseValue = wasm.TS_ChannelUpdate_get_contents(this_ptr);
23455 return nativeResponseValue;
23457 // void ChannelUpdate_set_contents(struct LDKChannelUpdate *NONNULL_PTR this_ptr, struct LDKUnsignedChannelUpdate val);
23459 export function ChannelUpdate_set_contents(this_ptr: number, val: number): void {
23460 if(!isWasmInitialized) {
23461 throw new Error("initializeWasm() must be awaited first!");
23463 const nativeResponseValue = wasm.TS_ChannelUpdate_set_contents(this_ptr, val);
23464 // debug statements here
23466 // MUST_USE_RES struct LDKChannelUpdate ChannelUpdate_new(struct LDKSignature signature_arg, struct LDKUnsignedChannelUpdate contents_arg);
23468 export function ChannelUpdate_new(signature_arg: number, contents_arg: number): number {
23469 if(!isWasmInitialized) {
23470 throw new Error("initializeWasm() must be awaited first!");
23472 const nativeResponseValue = wasm.TS_ChannelUpdate_new(signature_arg, contents_arg);
23473 return nativeResponseValue;
23475 // uintptr_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg);
23477 export function ChannelUpdate_clone_ptr(arg: number): number {
23478 if(!isWasmInitialized) {
23479 throw new Error("initializeWasm() must be awaited first!");
23481 const nativeResponseValue = wasm.TS_ChannelUpdate_clone_ptr(arg);
23482 return nativeResponseValue;
23484 // struct LDKChannelUpdate ChannelUpdate_clone(const struct LDKChannelUpdate *NONNULL_PTR orig);
23486 export function ChannelUpdate_clone(orig: number): number {
23487 if(!isWasmInitialized) {
23488 throw new Error("initializeWasm() must be awaited first!");
23490 const nativeResponseValue = wasm.TS_ChannelUpdate_clone(orig);
23491 return nativeResponseValue;
23493 // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
23495 export function QueryChannelRange_free(this_obj: number): void {
23496 if(!isWasmInitialized) {
23497 throw new Error("initializeWasm() must be awaited first!");
23499 const nativeResponseValue = wasm.TS_QueryChannelRange_free(this_obj);
23500 // debug statements here
23502 // const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
23504 export function QueryChannelRange_get_chain_hash(this_ptr: number): number {
23505 if(!isWasmInitialized) {
23506 throw new Error("initializeWasm() must be awaited first!");
23508 const nativeResponseValue = wasm.TS_QueryChannelRange_get_chain_hash(this_ptr);
23509 return nativeResponseValue;
23511 // void QueryChannelRange_set_chain_hash(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23513 export function QueryChannelRange_set_chain_hash(this_ptr: number, val: number): void {
23514 if(!isWasmInitialized) {
23515 throw new Error("initializeWasm() must be awaited first!");
23517 const nativeResponseValue = wasm.TS_QueryChannelRange_set_chain_hash(this_ptr, val);
23518 // debug statements here
23520 // uint32_t QueryChannelRange_get_first_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
23522 export function QueryChannelRange_get_first_blocknum(this_ptr: number): number {
23523 if(!isWasmInitialized) {
23524 throw new Error("initializeWasm() must be awaited first!");
23526 const nativeResponseValue = wasm.TS_QueryChannelRange_get_first_blocknum(this_ptr);
23527 return nativeResponseValue;
23529 // void QueryChannelRange_set_first_blocknum(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23531 export function QueryChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
23532 if(!isWasmInitialized) {
23533 throw new Error("initializeWasm() must be awaited first!");
23535 const nativeResponseValue = wasm.TS_QueryChannelRange_set_first_blocknum(this_ptr, val);
23536 // debug statements here
23538 // uint32_t QueryChannelRange_get_number_of_blocks(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr);
23540 export function QueryChannelRange_get_number_of_blocks(this_ptr: number): number {
23541 if(!isWasmInitialized) {
23542 throw new Error("initializeWasm() must be awaited first!");
23544 const nativeResponseValue = wasm.TS_QueryChannelRange_get_number_of_blocks(this_ptr);
23545 return nativeResponseValue;
23547 // void QueryChannelRange_set_number_of_blocks(struct LDKQueryChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23549 export function QueryChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
23550 if(!isWasmInitialized) {
23551 throw new Error("initializeWasm() must be awaited first!");
23553 const nativeResponseValue = wasm.TS_QueryChannelRange_set_number_of_blocks(this_ptr, val);
23554 // debug statements here
23556 // MUST_USE_RES struct LDKQueryChannelRange QueryChannelRange_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_blocknum_arg, uint32_t number_of_blocks_arg);
23558 export function QueryChannelRange_new(chain_hash_arg: number, first_blocknum_arg: number, number_of_blocks_arg: number): number {
23559 if(!isWasmInitialized) {
23560 throw new Error("initializeWasm() must be awaited first!");
23562 const nativeResponseValue = wasm.TS_QueryChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg);
23563 return nativeResponseValue;
23565 // uintptr_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg);
23567 export function QueryChannelRange_clone_ptr(arg: number): number {
23568 if(!isWasmInitialized) {
23569 throw new Error("initializeWasm() must be awaited first!");
23571 const nativeResponseValue = wasm.TS_QueryChannelRange_clone_ptr(arg);
23572 return nativeResponseValue;
23574 // struct LDKQueryChannelRange QueryChannelRange_clone(const struct LDKQueryChannelRange *NONNULL_PTR orig);
23576 export function QueryChannelRange_clone(orig: number): number {
23577 if(!isWasmInitialized) {
23578 throw new Error("initializeWasm() must be awaited first!");
23580 const nativeResponseValue = wasm.TS_QueryChannelRange_clone(orig);
23581 return nativeResponseValue;
23583 // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
23585 export function ReplyChannelRange_free(this_obj: number): void {
23586 if(!isWasmInitialized) {
23587 throw new Error("initializeWasm() must be awaited first!");
23589 const nativeResponseValue = wasm.TS_ReplyChannelRange_free(this_obj);
23590 // debug statements here
23592 // const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
23594 export function ReplyChannelRange_get_chain_hash(this_ptr: number): number {
23595 if(!isWasmInitialized) {
23596 throw new Error("initializeWasm() must be awaited first!");
23598 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_chain_hash(this_ptr);
23599 return nativeResponseValue;
23601 // void ReplyChannelRange_set_chain_hash(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23603 export function ReplyChannelRange_set_chain_hash(this_ptr: number, val: number): void {
23604 if(!isWasmInitialized) {
23605 throw new Error("initializeWasm() must be awaited first!");
23607 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_chain_hash(this_ptr, val);
23608 // debug statements here
23610 // uint32_t ReplyChannelRange_get_first_blocknum(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
23612 export function ReplyChannelRange_get_first_blocknum(this_ptr: number): number {
23613 if(!isWasmInitialized) {
23614 throw new Error("initializeWasm() must be awaited first!");
23616 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_first_blocknum(this_ptr);
23617 return nativeResponseValue;
23619 // void ReplyChannelRange_set_first_blocknum(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23621 export function ReplyChannelRange_set_first_blocknum(this_ptr: number, val: number): void {
23622 if(!isWasmInitialized) {
23623 throw new Error("initializeWasm() must be awaited first!");
23625 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_first_blocknum(this_ptr, val);
23626 // debug statements here
23628 // uint32_t ReplyChannelRange_get_number_of_blocks(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
23630 export function ReplyChannelRange_get_number_of_blocks(this_ptr: number): number {
23631 if(!isWasmInitialized) {
23632 throw new Error("initializeWasm() must be awaited first!");
23634 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_number_of_blocks(this_ptr);
23635 return nativeResponseValue;
23637 // void ReplyChannelRange_set_number_of_blocks(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, uint32_t val);
23639 export function ReplyChannelRange_set_number_of_blocks(this_ptr: number, val: number): void {
23640 if(!isWasmInitialized) {
23641 throw new Error("initializeWasm() must be awaited first!");
23643 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_number_of_blocks(this_ptr, val);
23644 // debug statements here
23646 // bool ReplyChannelRange_get_sync_complete(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr);
23648 export function ReplyChannelRange_get_sync_complete(this_ptr: number): boolean {
23649 if(!isWasmInitialized) {
23650 throw new Error("initializeWasm() must be awaited first!");
23652 const nativeResponseValue = wasm.TS_ReplyChannelRange_get_sync_complete(this_ptr);
23653 return nativeResponseValue;
23655 // void ReplyChannelRange_set_sync_complete(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, bool val);
23657 export function ReplyChannelRange_set_sync_complete(this_ptr: number, val: boolean): void {
23658 if(!isWasmInitialized) {
23659 throw new Error("initializeWasm() must be awaited first!");
23661 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_sync_complete(this_ptr, val);
23662 // debug statements here
23664 // void ReplyChannelRange_set_short_channel_ids(struct LDKReplyChannelRange *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
23666 export function ReplyChannelRange_set_short_channel_ids(this_ptr: number, val: number): void {
23667 if(!isWasmInitialized) {
23668 throw new Error("initializeWasm() must be awaited first!");
23670 const nativeResponseValue = wasm.TS_ReplyChannelRange_set_short_channel_ids(this_ptr, val);
23671 // debug statements here
23673 // 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);
23675 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 {
23676 if(!isWasmInitialized) {
23677 throw new Error("initializeWasm() must be awaited first!");
23679 const nativeResponseValue = wasm.TS_ReplyChannelRange_new(chain_hash_arg, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg);
23680 return nativeResponseValue;
23682 // uintptr_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg);
23684 export function ReplyChannelRange_clone_ptr(arg: number): number {
23685 if(!isWasmInitialized) {
23686 throw new Error("initializeWasm() must be awaited first!");
23688 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone_ptr(arg);
23689 return nativeResponseValue;
23691 // struct LDKReplyChannelRange ReplyChannelRange_clone(const struct LDKReplyChannelRange *NONNULL_PTR orig);
23693 export function ReplyChannelRange_clone(orig: number): number {
23694 if(!isWasmInitialized) {
23695 throw new Error("initializeWasm() must be awaited first!");
23697 const nativeResponseValue = wasm.TS_ReplyChannelRange_clone(orig);
23698 return nativeResponseValue;
23700 // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
23702 export function QueryShortChannelIds_free(this_obj: number): void {
23703 if(!isWasmInitialized) {
23704 throw new Error("initializeWasm() must be awaited first!");
23706 const nativeResponseValue = wasm.TS_QueryShortChannelIds_free(this_obj);
23707 // debug statements here
23709 // const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
23711 export function QueryShortChannelIds_get_chain_hash(this_ptr: number): number {
23712 if(!isWasmInitialized) {
23713 throw new Error("initializeWasm() must be awaited first!");
23715 const nativeResponseValue = wasm.TS_QueryShortChannelIds_get_chain_hash(this_ptr);
23716 return nativeResponseValue;
23718 // void QueryShortChannelIds_set_chain_hash(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23720 export function QueryShortChannelIds_set_chain_hash(this_ptr: number, val: number): void {
23721 if(!isWasmInitialized) {
23722 throw new Error("initializeWasm() must be awaited first!");
23724 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_chain_hash(this_ptr, val);
23725 // debug statements here
23727 // void QueryShortChannelIds_set_short_channel_ids(struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
23729 export function QueryShortChannelIds_set_short_channel_ids(this_ptr: number, val: number): void {
23730 if(!isWasmInitialized) {
23731 throw new Error("initializeWasm() must be awaited first!");
23733 const nativeResponseValue = wasm.TS_QueryShortChannelIds_set_short_channel_ids(this_ptr, val);
23734 // debug statements here
23736 // MUST_USE_RES struct LDKQueryShortChannelIds QueryShortChannelIds_new(struct LDKThirtyTwoBytes chain_hash_arg, struct LDKCVec_u64Z short_channel_ids_arg);
23738 export function QueryShortChannelIds_new(chain_hash_arg: number, short_channel_ids_arg: number): number {
23739 if(!isWasmInitialized) {
23740 throw new Error("initializeWasm() must be awaited first!");
23742 const nativeResponseValue = wasm.TS_QueryShortChannelIds_new(chain_hash_arg, short_channel_ids_arg);
23743 return nativeResponseValue;
23745 // uintptr_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg);
23747 export function QueryShortChannelIds_clone_ptr(arg: number): number {
23748 if(!isWasmInitialized) {
23749 throw new Error("initializeWasm() must be awaited first!");
23751 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone_ptr(arg);
23752 return nativeResponseValue;
23754 // struct LDKQueryShortChannelIds QueryShortChannelIds_clone(const struct LDKQueryShortChannelIds *NONNULL_PTR orig);
23756 export function QueryShortChannelIds_clone(orig: number): number {
23757 if(!isWasmInitialized) {
23758 throw new Error("initializeWasm() must be awaited first!");
23760 const nativeResponseValue = wasm.TS_QueryShortChannelIds_clone(orig);
23761 return nativeResponseValue;
23763 // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
23765 export function ReplyShortChannelIdsEnd_free(this_obj: number): void {
23766 if(!isWasmInitialized) {
23767 throw new Error("initializeWasm() must be awaited first!");
23769 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_free(this_obj);
23770 // debug statements here
23772 // const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
23774 export function ReplyShortChannelIdsEnd_get_chain_hash(this_ptr: number): number {
23775 if(!isWasmInitialized) {
23776 throw new Error("initializeWasm() must be awaited first!");
23778 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_chain_hash(this_ptr);
23779 return nativeResponseValue;
23781 // void ReplyShortChannelIdsEnd_set_chain_hash(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23783 export function ReplyShortChannelIdsEnd_set_chain_hash(this_ptr: number, val: number): void {
23784 if(!isWasmInitialized) {
23785 throw new Error("initializeWasm() must be awaited first!");
23787 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_chain_hash(this_ptr, val);
23788 // debug statements here
23790 // bool ReplyShortChannelIdsEnd_get_full_information(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr);
23792 export function ReplyShortChannelIdsEnd_get_full_information(this_ptr: number): boolean {
23793 if(!isWasmInitialized) {
23794 throw new Error("initializeWasm() must be awaited first!");
23796 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_get_full_information(this_ptr);
23797 return nativeResponseValue;
23799 // void ReplyShortChannelIdsEnd_set_full_information(struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr, bool val);
23801 export function ReplyShortChannelIdsEnd_set_full_information(this_ptr: number, val: boolean): void {
23802 if(!isWasmInitialized) {
23803 throw new Error("initializeWasm() must be awaited first!");
23805 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_set_full_information(this_ptr, val);
23806 // debug statements here
23808 // MUST_USE_RES struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_new(struct LDKThirtyTwoBytes chain_hash_arg, bool full_information_arg);
23810 export function ReplyShortChannelIdsEnd_new(chain_hash_arg: number, full_information_arg: boolean): number {
23811 if(!isWasmInitialized) {
23812 throw new Error("initializeWasm() must be awaited first!");
23814 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_new(chain_hash_arg, full_information_arg);
23815 return nativeResponseValue;
23817 // uintptr_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg);
23819 export function ReplyShortChannelIdsEnd_clone_ptr(arg: number): number {
23820 if(!isWasmInitialized) {
23821 throw new Error("initializeWasm() must be awaited first!");
23823 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone_ptr(arg);
23824 return nativeResponseValue;
23826 // struct LDKReplyShortChannelIdsEnd ReplyShortChannelIdsEnd_clone(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR orig);
23828 export function ReplyShortChannelIdsEnd_clone(orig: number): number {
23829 if(!isWasmInitialized) {
23830 throw new Error("initializeWasm() must be awaited first!");
23832 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_clone(orig);
23833 return nativeResponseValue;
23835 // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
23837 export function GossipTimestampFilter_free(this_obj: number): void {
23838 if(!isWasmInitialized) {
23839 throw new Error("initializeWasm() must be awaited first!");
23841 const nativeResponseValue = wasm.TS_GossipTimestampFilter_free(this_obj);
23842 // debug statements here
23844 // const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
23846 export function GossipTimestampFilter_get_chain_hash(this_ptr: number): number {
23847 if(!isWasmInitialized) {
23848 throw new Error("initializeWasm() must be awaited first!");
23850 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_chain_hash(this_ptr);
23851 return nativeResponseValue;
23853 // void GossipTimestampFilter_set_chain_hash(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
23855 export function GossipTimestampFilter_set_chain_hash(this_ptr: number, val: number): void {
23856 if(!isWasmInitialized) {
23857 throw new Error("initializeWasm() must be awaited first!");
23859 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_chain_hash(this_ptr, val);
23860 // debug statements here
23862 // uint32_t GossipTimestampFilter_get_first_timestamp(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
23864 export function GossipTimestampFilter_get_first_timestamp(this_ptr: number): number {
23865 if(!isWasmInitialized) {
23866 throw new Error("initializeWasm() must be awaited first!");
23868 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_first_timestamp(this_ptr);
23869 return nativeResponseValue;
23871 // void GossipTimestampFilter_set_first_timestamp(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
23873 export function GossipTimestampFilter_set_first_timestamp(this_ptr: number, val: number): void {
23874 if(!isWasmInitialized) {
23875 throw new Error("initializeWasm() must be awaited first!");
23877 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_first_timestamp(this_ptr, val);
23878 // debug statements here
23880 // uint32_t GossipTimestampFilter_get_timestamp_range(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr);
23882 export function GossipTimestampFilter_get_timestamp_range(this_ptr: number): number {
23883 if(!isWasmInitialized) {
23884 throw new Error("initializeWasm() must be awaited first!");
23886 const nativeResponseValue = wasm.TS_GossipTimestampFilter_get_timestamp_range(this_ptr);
23887 return nativeResponseValue;
23889 // void GossipTimestampFilter_set_timestamp_range(struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr, uint32_t val);
23891 export function GossipTimestampFilter_set_timestamp_range(this_ptr: number, val: number): void {
23892 if(!isWasmInitialized) {
23893 throw new Error("initializeWasm() must be awaited first!");
23895 const nativeResponseValue = wasm.TS_GossipTimestampFilter_set_timestamp_range(this_ptr, val);
23896 // debug statements here
23898 // MUST_USE_RES struct LDKGossipTimestampFilter GossipTimestampFilter_new(struct LDKThirtyTwoBytes chain_hash_arg, uint32_t first_timestamp_arg, uint32_t timestamp_range_arg);
23900 export function GossipTimestampFilter_new(chain_hash_arg: number, first_timestamp_arg: number, timestamp_range_arg: number): number {
23901 if(!isWasmInitialized) {
23902 throw new Error("initializeWasm() must be awaited first!");
23904 const nativeResponseValue = wasm.TS_GossipTimestampFilter_new(chain_hash_arg, first_timestamp_arg, timestamp_range_arg);
23905 return nativeResponseValue;
23907 // uintptr_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg);
23909 export function GossipTimestampFilter_clone_ptr(arg: number): number {
23910 if(!isWasmInitialized) {
23911 throw new Error("initializeWasm() must be awaited first!");
23913 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone_ptr(arg);
23914 return nativeResponseValue;
23916 // struct LDKGossipTimestampFilter GossipTimestampFilter_clone(const struct LDKGossipTimestampFilter *NONNULL_PTR orig);
23918 export function GossipTimestampFilter_clone(orig: number): number {
23919 if(!isWasmInitialized) {
23920 throw new Error("initializeWasm() must be awaited first!");
23922 const nativeResponseValue = wasm.TS_GossipTimestampFilter_clone(orig);
23923 return nativeResponseValue;
23925 // void ErrorAction_free(struct LDKErrorAction this_ptr);
23927 export function ErrorAction_free(this_ptr: number): void {
23928 if(!isWasmInitialized) {
23929 throw new Error("initializeWasm() must be awaited first!");
23931 const nativeResponseValue = wasm.TS_ErrorAction_free(this_ptr);
23932 // debug statements here
23934 // uintptr_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg);
23936 export function ErrorAction_clone_ptr(arg: number): number {
23937 if(!isWasmInitialized) {
23938 throw new Error("initializeWasm() must be awaited first!");
23940 const nativeResponseValue = wasm.TS_ErrorAction_clone_ptr(arg);
23941 return nativeResponseValue;
23943 // struct LDKErrorAction ErrorAction_clone(const struct LDKErrorAction *NONNULL_PTR orig);
23945 export function ErrorAction_clone(orig: number): number {
23946 if(!isWasmInitialized) {
23947 throw new Error("initializeWasm() must be awaited first!");
23949 const nativeResponseValue = wasm.TS_ErrorAction_clone(orig);
23950 return nativeResponseValue;
23952 // struct LDKErrorAction ErrorAction_disconnect_peer(struct LDKErrorMessage msg);
23954 export function ErrorAction_disconnect_peer(msg: number): number {
23955 if(!isWasmInitialized) {
23956 throw new Error("initializeWasm() must be awaited first!");
23958 const nativeResponseValue = wasm.TS_ErrorAction_disconnect_peer(msg);
23959 return nativeResponseValue;
23961 // struct LDKErrorAction ErrorAction_ignore_error(void);
23963 export function ErrorAction_ignore_error(): number {
23964 if(!isWasmInitialized) {
23965 throw new Error("initializeWasm() must be awaited first!");
23967 const nativeResponseValue = wasm.TS_ErrorAction_ignore_error();
23968 return nativeResponseValue;
23970 // struct LDKErrorAction ErrorAction_ignore_and_log(enum LDKLevel a);
23972 export function ErrorAction_ignore_and_log(a: Level): number {
23973 if(!isWasmInitialized) {
23974 throw new Error("initializeWasm() must be awaited first!");
23976 const nativeResponseValue = wasm.TS_ErrorAction_ignore_and_log(a);
23977 return nativeResponseValue;
23979 // struct LDKErrorAction ErrorAction_ignore_duplicate_gossip(void);
23981 export function ErrorAction_ignore_duplicate_gossip(): number {
23982 if(!isWasmInitialized) {
23983 throw new Error("initializeWasm() must be awaited first!");
23985 const nativeResponseValue = wasm.TS_ErrorAction_ignore_duplicate_gossip();
23986 return nativeResponseValue;
23988 // struct LDKErrorAction ErrorAction_send_error_message(struct LDKErrorMessage msg);
23990 export function ErrorAction_send_error_message(msg: number): number {
23991 if(!isWasmInitialized) {
23992 throw new Error("initializeWasm() must be awaited first!");
23994 const nativeResponseValue = wasm.TS_ErrorAction_send_error_message(msg);
23995 return nativeResponseValue;
23997 // struct LDKErrorAction ErrorAction_send_warning_message(struct LDKWarningMessage msg, enum LDKLevel log_level);
23999 export function ErrorAction_send_warning_message(msg: number, log_level: Level): number {
24000 if(!isWasmInitialized) {
24001 throw new Error("initializeWasm() must be awaited first!");
24003 const nativeResponseValue = wasm.TS_ErrorAction_send_warning_message(msg, log_level);
24004 return nativeResponseValue;
24006 // void LightningError_free(struct LDKLightningError this_obj);
24008 export function LightningError_free(this_obj: number): void {
24009 if(!isWasmInitialized) {
24010 throw new Error("initializeWasm() must be awaited first!");
24012 const nativeResponseValue = wasm.TS_LightningError_free(this_obj);
24013 // debug statements here
24015 // struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
24017 export function LightningError_get_err(this_ptr: number): number {
24018 if(!isWasmInitialized) {
24019 throw new Error("initializeWasm() must be awaited first!");
24021 const nativeResponseValue = wasm.TS_LightningError_get_err(this_ptr);
24022 return nativeResponseValue;
24024 // void LightningError_set_err(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKStr val);
24026 export function LightningError_set_err(this_ptr: number, val: number): void {
24027 if(!isWasmInitialized) {
24028 throw new Error("initializeWasm() must be awaited first!");
24030 const nativeResponseValue = wasm.TS_LightningError_set_err(this_ptr, val);
24031 // debug statements here
24033 // struct LDKErrorAction LightningError_get_action(const struct LDKLightningError *NONNULL_PTR this_ptr);
24035 export function LightningError_get_action(this_ptr: number): number {
24036 if(!isWasmInitialized) {
24037 throw new Error("initializeWasm() must be awaited first!");
24039 const nativeResponseValue = wasm.TS_LightningError_get_action(this_ptr);
24040 return nativeResponseValue;
24042 // void LightningError_set_action(struct LDKLightningError *NONNULL_PTR this_ptr, struct LDKErrorAction val);
24044 export function LightningError_set_action(this_ptr: number, val: number): void {
24045 if(!isWasmInitialized) {
24046 throw new Error("initializeWasm() must be awaited first!");
24048 const nativeResponseValue = wasm.TS_LightningError_set_action(this_ptr, val);
24049 // debug statements here
24051 // MUST_USE_RES struct LDKLightningError LightningError_new(struct LDKStr err_arg, struct LDKErrorAction action_arg);
24053 export function LightningError_new(err_arg: number, action_arg: number): number {
24054 if(!isWasmInitialized) {
24055 throw new Error("initializeWasm() must be awaited first!");
24057 const nativeResponseValue = wasm.TS_LightningError_new(err_arg, action_arg);
24058 return nativeResponseValue;
24060 // uintptr_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg);
24062 export function LightningError_clone_ptr(arg: number): number {
24063 if(!isWasmInitialized) {
24064 throw new Error("initializeWasm() must be awaited first!");
24066 const nativeResponseValue = wasm.TS_LightningError_clone_ptr(arg);
24067 return nativeResponseValue;
24069 // struct LDKLightningError LightningError_clone(const struct LDKLightningError *NONNULL_PTR orig);
24071 export function LightningError_clone(orig: number): number {
24072 if(!isWasmInitialized) {
24073 throw new Error("initializeWasm() must be awaited first!");
24075 const nativeResponseValue = wasm.TS_LightningError_clone(orig);
24076 return nativeResponseValue;
24078 // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
24080 export function CommitmentUpdate_free(this_obj: number): void {
24081 if(!isWasmInitialized) {
24082 throw new Error("initializeWasm() must be awaited first!");
24084 const nativeResponseValue = wasm.TS_CommitmentUpdate_free(this_obj);
24085 // debug statements here
24087 // struct LDKCVec_UpdateAddHTLCZ CommitmentUpdate_get_update_add_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24089 export function CommitmentUpdate_get_update_add_htlcs(this_ptr: number): number {
24090 if(!isWasmInitialized) {
24091 throw new Error("initializeWasm() must be awaited first!");
24093 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_add_htlcs(this_ptr);
24094 return nativeResponseValue;
24096 // void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
24098 export function CommitmentUpdate_set_update_add_htlcs(this_ptr: number, val: number): void {
24099 if(!isWasmInitialized) {
24100 throw new Error("initializeWasm() must be awaited first!");
24102 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_add_htlcs(this_ptr, val);
24103 // debug statements here
24105 // struct LDKCVec_UpdateFulfillHTLCZ CommitmentUpdate_get_update_fulfill_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24107 export function CommitmentUpdate_get_update_fulfill_htlcs(this_ptr: number): number {
24108 if(!isWasmInitialized) {
24109 throw new Error("initializeWasm() must be awaited first!");
24111 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fulfill_htlcs(this_ptr);
24112 return nativeResponseValue;
24114 // void CommitmentUpdate_set_update_fulfill_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFulfillHTLCZ val);
24116 export function CommitmentUpdate_set_update_fulfill_htlcs(this_ptr: number, val: number): void {
24117 if(!isWasmInitialized) {
24118 throw new Error("initializeWasm() must be awaited first!");
24120 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fulfill_htlcs(this_ptr, val);
24121 // debug statements here
24123 // struct LDKCVec_UpdateFailHTLCZ CommitmentUpdate_get_update_fail_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24125 export function CommitmentUpdate_get_update_fail_htlcs(this_ptr: number): number {
24126 if(!isWasmInitialized) {
24127 throw new Error("initializeWasm() must be awaited first!");
24129 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_htlcs(this_ptr);
24130 return nativeResponseValue;
24132 // void CommitmentUpdate_set_update_fail_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailHTLCZ val);
24134 export function CommitmentUpdate_set_update_fail_htlcs(this_ptr: number, val: number): void {
24135 if(!isWasmInitialized) {
24136 throw new Error("initializeWasm() must be awaited first!");
24138 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_htlcs(this_ptr, val);
24139 // debug statements here
24141 // struct LDKCVec_UpdateFailMalformedHTLCZ CommitmentUpdate_get_update_fail_malformed_htlcs(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24143 export function CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr: number): number {
24144 if(!isWasmInitialized) {
24145 throw new Error("initializeWasm() must be awaited first!");
24147 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fail_malformed_htlcs(this_ptr);
24148 return nativeResponseValue;
24150 // void CommitmentUpdate_set_update_fail_malformed_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateFailMalformedHTLCZ val);
24152 export function CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr: number, val: number): void {
24153 if(!isWasmInitialized) {
24154 throw new Error("initializeWasm() must be awaited first!");
24156 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fail_malformed_htlcs(this_ptr, val);
24157 // debug statements here
24159 // struct LDKUpdateFee CommitmentUpdate_get_update_fee(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24161 export function CommitmentUpdate_get_update_fee(this_ptr: number): number {
24162 if(!isWasmInitialized) {
24163 throw new Error("initializeWasm() must be awaited first!");
24165 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_update_fee(this_ptr);
24166 return nativeResponseValue;
24168 // void CommitmentUpdate_set_update_fee(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKUpdateFee val);
24170 export function CommitmentUpdate_set_update_fee(this_ptr: number, val: number): void {
24171 if(!isWasmInitialized) {
24172 throw new Error("initializeWasm() must be awaited first!");
24174 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_update_fee(this_ptr, val);
24175 // debug statements here
24177 // struct LDKCommitmentSigned CommitmentUpdate_get_commitment_signed(const struct LDKCommitmentUpdate *NONNULL_PTR this_ptr);
24179 export function CommitmentUpdate_get_commitment_signed(this_ptr: number): number {
24180 if(!isWasmInitialized) {
24181 throw new Error("initializeWasm() must be awaited first!");
24183 const nativeResponseValue = wasm.TS_CommitmentUpdate_get_commitment_signed(this_ptr);
24184 return nativeResponseValue;
24186 // void CommitmentUpdate_set_commitment_signed(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCommitmentSigned val);
24188 export function CommitmentUpdate_set_commitment_signed(this_ptr: number, val: number): void {
24189 if(!isWasmInitialized) {
24190 throw new Error("initializeWasm() must be awaited first!");
24192 const nativeResponseValue = wasm.TS_CommitmentUpdate_set_commitment_signed(this_ptr, val);
24193 // debug statements here
24195 // 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);
24197 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 {
24198 if(!isWasmInitialized) {
24199 throw new Error("initializeWasm() must be awaited first!");
24201 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);
24202 return nativeResponseValue;
24204 // uintptr_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg);
24206 export function CommitmentUpdate_clone_ptr(arg: number): number {
24207 if(!isWasmInitialized) {
24208 throw new Error("initializeWasm() must be awaited first!");
24210 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone_ptr(arg);
24211 return nativeResponseValue;
24213 // struct LDKCommitmentUpdate CommitmentUpdate_clone(const struct LDKCommitmentUpdate *NONNULL_PTR orig);
24215 export function CommitmentUpdate_clone(orig: number): number {
24216 if(!isWasmInitialized) {
24217 throw new Error("initializeWasm() must be awaited first!");
24219 const nativeResponseValue = wasm.TS_CommitmentUpdate_clone(orig);
24220 return nativeResponseValue;
24222 // void ChannelMessageHandler_free(struct LDKChannelMessageHandler this_ptr);
24224 export function ChannelMessageHandler_free(this_ptr: number): void {
24225 if(!isWasmInitialized) {
24226 throw new Error("initializeWasm() must be awaited first!");
24228 const nativeResponseValue = wasm.TS_ChannelMessageHandler_free(this_ptr);
24229 // debug statements here
24231 // void RoutingMessageHandler_free(struct LDKRoutingMessageHandler this_ptr);
24233 export function RoutingMessageHandler_free(this_ptr: number): void {
24234 if(!isWasmInitialized) {
24235 throw new Error("initializeWasm() must be awaited first!");
24237 const nativeResponseValue = wasm.TS_RoutingMessageHandler_free(this_ptr);
24238 // debug statements here
24240 // struct LDKCVec_u8Z AcceptChannel_write(const struct LDKAcceptChannel *NONNULL_PTR obj);
24242 export function AcceptChannel_write(obj: number): number {
24243 if(!isWasmInitialized) {
24244 throw new Error("initializeWasm() must be awaited first!");
24246 const nativeResponseValue = wasm.TS_AcceptChannel_write(obj);
24247 return nativeResponseValue;
24249 // struct LDKCResult_AcceptChannelDecodeErrorZ AcceptChannel_read(struct LDKu8slice ser);
24251 export function AcceptChannel_read(ser: number): number {
24252 if(!isWasmInitialized) {
24253 throw new Error("initializeWasm() must be awaited first!");
24255 const nativeResponseValue = wasm.TS_AcceptChannel_read(ser);
24256 return nativeResponseValue;
24258 // struct LDKCVec_u8Z AnnouncementSignatures_write(const struct LDKAnnouncementSignatures *NONNULL_PTR obj);
24260 export function AnnouncementSignatures_write(obj: number): number {
24261 if(!isWasmInitialized) {
24262 throw new Error("initializeWasm() must be awaited first!");
24264 const nativeResponseValue = wasm.TS_AnnouncementSignatures_write(obj);
24265 return nativeResponseValue;
24267 // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ AnnouncementSignatures_read(struct LDKu8slice ser);
24269 export function AnnouncementSignatures_read(ser: number): number {
24270 if(!isWasmInitialized) {
24271 throw new Error("initializeWasm() must be awaited first!");
24273 const nativeResponseValue = wasm.TS_AnnouncementSignatures_read(ser);
24274 return nativeResponseValue;
24276 // struct LDKCVec_u8Z ChannelReestablish_write(const struct LDKChannelReestablish *NONNULL_PTR obj);
24278 export function ChannelReestablish_write(obj: number): number {
24279 if(!isWasmInitialized) {
24280 throw new Error("initializeWasm() must be awaited first!");
24282 const nativeResponseValue = wasm.TS_ChannelReestablish_write(obj);
24283 return nativeResponseValue;
24285 // struct LDKCResult_ChannelReestablishDecodeErrorZ ChannelReestablish_read(struct LDKu8slice ser);
24287 export function ChannelReestablish_read(ser: number): number {
24288 if(!isWasmInitialized) {
24289 throw new Error("initializeWasm() must be awaited first!");
24291 const nativeResponseValue = wasm.TS_ChannelReestablish_read(ser);
24292 return nativeResponseValue;
24294 // struct LDKCVec_u8Z ClosingSigned_write(const struct LDKClosingSigned *NONNULL_PTR obj);
24296 export function ClosingSigned_write(obj: number): number {
24297 if(!isWasmInitialized) {
24298 throw new Error("initializeWasm() must be awaited first!");
24300 const nativeResponseValue = wasm.TS_ClosingSigned_write(obj);
24301 return nativeResponseValue;
24303 // struct LDKCResult_ClosingSignedDecodeErrorZ ClosingSigned_read(struct LDKu8slice ser);
24305 export function ClosingSigned_read(ser: number): number {
24306 if(!isWasmInitialized) {
24307 throw new Error("initializeWasm() must be awaited first!");
24309 const nativeResponseValue = wasm.TS_ClosingSigned_read(ser);
24310 return nativeResponseValue;
24312 // struct LDKCVec_u8Z ClosingSignedFeeRange_write(const struct LDKClosingSignedFeeRange *NONNULL_PTR obj);
24314 export function ClosingSignedFeeRange_write(obj: number): number {
24315 if(!isWasmInitialized) {
24316 throw new Error("initializeWasm() must be awaited first!");
24318 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_write(obj);
24319 return nativeResponseValue;
24321 // struct LDKCResult_ClosingSignedFeeRangeDecodeErrorZ ClosingSignedFeeRange_read(struct LDKu8slice ser);
24323 export function ClosingSignedFeeRange_read(ser: number): number {
24324 if(!isWasmInitialized) {
24325 throw new Error("initializeWasm() must be awaited first!");
24327 const nativeResponseValue = wasm.TS_ClosingSignedFeeRange_read(ser);
24328 return nativeResponseValue;
24330 // struct LDKCVec_u8Z CommitmentSigned_write(const struct LDKCommitmentSigned *NONNULL_PTR obj);
24332 export function CommitmentSigned_write(obj: number): number {
24333 if(!isWasmInitialized) {
24334 throw new Error("initializeWasm() must be awaited first!");
24336 const nativeResponseValue = wasm.TS_CommitmentSigned_write(obj);
24337 return nativeResponseValue;
24339 // struct LDKCResult_CommitmentSignedDecodeErrorZ CommitmentSigned_read(struct LDKu8slice ser);
24341 export function CommitmentSigned_read(ser: number): number {
24342 if(!isWasmInitialized) {
24343 throw new Error("initializeWasm() must be awaited first!");
24345 const nativeResponseValue = wasm.TS_CommitmentSigned_read(ser);
24346 return nativeResponseValue;
24348 // struct LDKCVec_u8Z FundingCreated_write(const struct LDKFundingCreated *NONNULL_PTR obj);
24350 export function FundingCreated_write(obj: number): number {
24351 if(!isWasmInitialized) {
24352 throw new Error("initializeWasm() must be awaited first!");
24354 const nativeResponseValue = wasm.TS_FundingCreated_write(obj);
24355 return nativeResponseValue;
24357 // struct LDKCResult_FundingCreatedDecodeErrorZ FundingCreated_read(struct LDKu8slice ser);
24359 export function FundingCreated_read(ser: number): number {
24360 if(!isWasmInitialized) {
24361 throw new Error("initializeWasm() must be awaited first!");
24363 const nativeResponseValue = wasm.TS_FundingCreated_read(ser);
24364 return nativeResponseValue;
24366 // struct LDKCVec_u8Z FundingSigned_write(const struct LDKFundingSigned *NONNULL_PTR obj);
24368 export function FundingSigned_write(obj: number): number {
24369 if(!isWasmInitialized) {
24370 throw new Error("initializeWasm() must be awaited first!");
24372 const nativeResponseValue = wasm.TS_FundingSigned_write(obj);
24373 return nativeResponseValue;
24375 // struct LDKCResult_FundingSignedDecodeErrorZ FundingSigned_read(struct LDKu8slice ser);
24377 export function FundingSigned_read(ser: number): number {
24378 if(!isWasmInitialized) {
24379 throw new Error("initializeWasm() must be awaited first!");
24381 const nativeResponseValue = wasm.TS_FundingSigned_read(ser);
24382 return nativeResponseValue;
24384 // struct LDKCVec_u8Z ChannelReady_write(const struct LDKChannelReady *NONNULL_PTR obj);
24386 export function ChannelReady_write(obj: number): number {
24387 if(!isWasmInitialized) {
24388 throw new Error("initializeWasm() must be awaited first!");
24390 const nativeResponseValue = wasm.TS_ChannelReady_write(obj);
24391 return nativeResponseValue;
24393 // struct LDKCResult_ChannelReadyDecodeErrorZ ChannelReady_read(struct LDKu8slice ser);
24395 export function ChannelReady_read(ser: number): number {
24396 if(!isWasmInitialized) {
24397 throw new Error("initializeWasm() must be awaited first!");
24399 const nativeResponseValue = wasm.TS_ChannelReady_read(ser);
24400 return nativeResponseValue;
24402 // struct LDKCVec_u8Z Init_write(const struct LDKInit *NONNULL_PTR obj);
24404 export function Init_write(obj: number): number {
24405 if(!isWasmInitialized) {
24406 throw new Error("initializeWasm() must be awaited first!");
24408 const nativeResponseValue = wasm.TS_Init_write(obj);
24409 return nativeResponseValue;
24411 // struct LDKCResult_InitDecodeErrorZ Init_read(struct LDKu8slice ser);
24413 export function Init_read(ser: number): number {
24414 if(!isWasmInitialized) {
24415 throw new Error("initializeWasm() must be awaited first!");
24417 const nativeResponseValue = wasm.TS_Init_read(ser);
24418 return nativeResponseValue;
24420 // struct LDKCVec_u8Z OpenChannel_write(const struct LDKOpenChannel *NONNULL_PTR obj);
24422 export function OpenChannel_write(obj: number): number {
24423 if(!isWasmInitialized) {
24424 throw new Error("initializeWasm() must be awaited first!");
24426 const nativeResponseValue = wasm.TS_OpenChannel_write(obj);
24427 return nativeResponseValue;
24429 // struct LDKCResult_OpenChannelDecodeErrorZ OpenChannel_read(struct LDKu8slice ser);
24431 export function OpenChannel_read(ser: number): number {
24432 if(!isWasmInitialized) {
24433 throw new Error("initializeWasm() must be awaited first!");
24435 const nativeResponseValue = wasm.TS_OpenChannel_read(ser);
24436 return nativeResponseValue;
24438 // struct LDKCVec_u8Z RevokeAndACK_write(const struct LDKRevokeAndACK *NONNULL_PTR obj);
24440 export function RevokeAndACK_write(obj: number): number {
24441 if(!isWasmInitialized) {
24442 throw new Error("initializeWasm() must be awaited first!");
24444 const nativeResponseValue = wasm.TS_RevokeAndACK_write(obj);
24445 return nativeResponseValue;
24447 // struct LDKCResult_RevokeAndACKDecodeErrorZ RevokeAndACK_read(struct LDKu8slice ser);
24449 export function RevokeAndACK_read(ser: number): number {
24450 if(!isWasmInitialized) {
24451 throw new Error("initializeWasm() must be awaited first!");
24453 const nativeResponseValue = wasm.TS_RevokeAndACK_read(ser);
24454 return nativeResponseValue;
24456 // struct LDKCVec_u8Z Shutdown_write(const struct LDKShutdown *NONNULL_PTR obj);
24458 export function Shutdown_write(obj: number): number {
24459 if(!isWasmInitialized) {
24460 throw new Error("initializeWasm() must be awaited first!");
24462 const nativeResponseValue = wasm.TS_Shutdown_write(obj);
24463 return nativeResponseValue;
24465 // struct LDKCResult_ShutdownDecodeErrorZ Shutdown_read(struct LDKu8slice ser);
24467 export function Shutdown_read(ser: number): number {
24468 if(!isWasmInitialized) {
24469 throw new Error("initializeWasm() must be awaited first!");
24471 const nativeResponseValue = wasm.TS_Shutdown_read(ser);
24472 return nativeResponseValue;
24474 // struct LDKCVec_u8Z UpdateFailHTLC_write(const struct LDKUpdateFailHTLC *NONNULL_PTR obj);
24476 export function UpdateFailHTLC_write(obj: number): number {
24477 if(!isWasmInitialized) {
24478 throw new Error("initializeWasm() must be awaited first!");
24480 const nativeResponseValue = wasm.TS_UpdateFailHTLC_write(obj);
24481 return nativeResponseValue;
24483 // struct LDKCResult_UpdateFailHTLCDecodeErrorZ UpdateFailHTLC_read(struct LDKu8slice ser);
24485 export function UpdateFailHTLC_read(ser: number): number {
24486 if(!isWasmInitialized) {
24487 throw new Error("initializeWasm() must be awaited first!");
24489 const nativeResponseValue = wasm.TS_UpdateFailHTLC_read(ser);
24490 return nativeResponseValue;
24492 // struct LDKCVec_u8Z UpdateFailMalformedHTLC_write(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR obj);
24494 export function UpdateFailMalformedHTLC_write(obj: number): number {
24495 if(!isWasmInitialized) {
24496 throw new Error("initializeWasm() must be awaited first!");
24498 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_write(obj);
24499 return nativeResponseValue;
24501 // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ UpdateFailMalformedHTLC_read(struct LDKu8slice ser);
24503 export function UpdateFailMalformedHTLC_read(ser: number): number {
24504 if(!isWasmInitialized) {
24505 throw new Error("initializeWasm() must be awaited first!");
24507 const nativeResponseValue = wasm.TS_UpdateFailMalformedHTLC_read(ser);
24508 return nativeResponseValue;
24510 // struct LDKCVec_u8Z UpdateFee_write(const struct LDKUpdateFee *NONNULL_PTR obj);
24512 export function UpdateFee_write(obj: number): number {
24513 if(!isWasmInitialized) {
24514 throw new Error("initializeWasm() must be awaited first!");
24516 const nativeResponseValue = wasm.TS_UpdateFee_write(obj);
24517 return nativeResponseValue;
24519 // struct LDKCResult_UpdateFeeDecodeErrorZ UpdateFee_read(struct LDKu8slice ser);
24521 export function UpdateFee_read(ser: number): number {
24522 if(!isWasmInitialized) {
24523 throw new Error("initializeWasm() must be awaited first!");
24525 const nativeResponseValue = wasm.TS_UpdateFee_read(ser);
24526 return nativeResponseValue;
24528 // struct LDKCVec_u8Z UpdateFulfillHTLC_write(const struct LDKUpdateFulfillHTLC *NONNULL_PTR obj);
24530 export function UpdateFulfillHTLC_write(obj: number): number {
24531 if(!isWasmInitialized) {
24532 throw new Error("initializeWasm() must be awaited first!");
24534 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_write(obj);
24535 return nativeResponseValue;
24537 // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ UpdateFulfillHTLC_read(struct LDKu8slice ser);
24539 export function UpdateFulfillHTLC_read(ser: number): number {
24540 if(!isWasmInitialized) {
24541 throw new Error("initializeWasm() must be awaited first!");
24543 const nativeResponseValue = wasm.TS_UpdateFulfillHTLC_read(ser);
24544 return nativeResponseValue;
24546 // struct LDKCVec_u8Z UpdateAddHTLC_write(const struct LDKUpdateAddHTLC *NONNULL_PTR obj);
24548 export function UpdateAddHTLC_write(obj: number): number {
24549 if(!isWasmInitialized) {
24550 throw new Error("initializeWasm() must be awaited first!");
24552 const nativeResponseValue = wasm.TS_UpdateAddHTLC_write(obj);
24553 return nativeResponseValue;
24555 // struct LDKCResult_UpdateAddHTLCDecodeErrorZ UpdateAddHTLC_read(struct LDKu8slice ser);
24557 export function UpdateAddHTLC_read(ser: number): number {
24558 if(!isWasmInitialized) {
24559 throw new Error("initializeWasm() must be awaited first!");
24561 const nativeResponseValue = wasm.TS_UpdateAddHTLC_read(ser);
24562 return nativeResponseValue;
24564 // struct LDKCVec_u8Z Ping_write(const struct LDKPing *NONNULL_PTR obj);
24566 export function Ping_write(obj: number): number {
24567 if(!isWasmInitialized) {
24568 throw new Error("initializeWasm() must be awaited first!");
24570 const nativeResponseValue = wasm.TS_Ping_write(obj);
24571 return nativeResponseValue;
24573 // struct LDKCResult_PingDecodeErrorZ Ping_read(struct LDKu8slice ser);
24575 export function Ping_read(ser: number): number {
24576 if(!isWasmInitialized) {
24577 throw new Error("initializeWasm() must be awaited first!");
24579 const nativeResponseValue = wasm.TS_Ping_read(ser);
24580 return nativeResponseValue;
24582 // struct LDKCVec_u8Z Pong_write(const struct LDKPong *NONNULL_PTR obj);
24584 export function Pong_write(obj: number): number {
24585 if(!isWasmInitialized) {
24586 throw new Error("initializeWasm() must be awaited first!");
24588 const nativeResponseValue = wasm.TS_Pong_write(obj);
24589 return nativeResponseValue;
24591 // struct LDKCResult_PongDecodeErrorZ Pong_read(struct LDKu8slice ser);
24593 export function Pong_read(ser: number): number {
24594 if(!isWasmInitialized) {
24595 throw new Error("initializeWasm() must be awaited first!");
24597 const nativeResponseValue = wasm.TS_Pong_read(ser);
24598 return nativeResponseValue;
24600 // struct LDKCVec_u8Z UnsignedChannelAnnouncement_write(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR obj);
24602 export function UnsignedChannelAnnouncement_write(obj: number): number {
24603 if(!isWasmInitialized) {
24604 throw new Error("initializeWasm() must be awaited first!");
24606 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_write(obj);
24607 return nativeResponseValue;
24609 // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ UnsignedChannelAnnouncement_read(struct LDKu8slice ser);
24611 export function UnsignedChannelAnnouncement_read(ser: number): number {
24612 if(!isWasmInitialized) {
24613 throw new Error("initializeWasm() must be awaited first!");
24615 const nativeResponseValue = wasm.TS_UnsignedChannelAnnouncement_read(ser);
24616 return nativeResponseValue;
24618 // struct LDKCVec_u8Z ChannelAnnouncement_write(const struct LDKChannelAnnouncement *NONNULL_PTR obj);
24620 export function ChannelAnnouncement_write(obj: number): number {
24621 if(!isWasmInitialized) {
24622 throw new Error("initializeWasm() must be awaited first!");
24624 const nativeResponseValue = wasm.TS_ChannelAnnouncement_write(obj);
24625 return nativeResponseValue;
24627 // struct LDKCResult_ChannelAnnouncementDecodeErrorZ ChannelAnnouncement_read(struct LDKu8slice ser);
24629 export function ChannelAnnouncement_read(ser: number): number {
24630 if(!isWasmInitialized) {
24631 throw new Error("initializeWasm() must be awaited first!");
24633 const nativeResponseValue = wasm.TS_ChannelAnnouncement_read(ser);
24634 return nativeResponseValue;
24636 // struct LDKCVec_u8Z UnsignedChannelUpdate_write(const struct LDKUnsignedChannelUpdate *NONNULL_PTR obj);
24638 export function UnsignedChannelUpdate_write(obj: number): number {
24639 if(!isWasmInitialized) {
24640 throw new Error("initializeWasm() must be awaited first!");
24642 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_write(obj);
24643 return nativeResponseValue;
24645 // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ UnsignedChannelUpdate_read(struct LDKu8slice ser);
24647 export function UnsignedChannelUpdate_read(ser: number): number {
24648 if(!isWasmInitialized) {
24649 throw new Error("initializeWasm() must be awaited first!");
24651 const nativeResponseValue = wasm.TS_UnsignedChannelUpdate_read(ser);
24652 return nativeResponseValue;
24654 // struct LDKCVec_u8Z ChannelUpdate_write(const struct LDKChannelUpdate *NONNULL_PTR obj);
24656 export function ChannelUpdate_write(obj: number): number {
24657 if(!isWasmInitialized) {
24658 throw new Error("initializeWasm() must be awaited first!");
24660 const nativeResponseValue = wasm.TS_ChannelUpdate_write(obj);
24661 return nativeResponseValue;
24663 // struct LDKCResult_ChannelUpdateDecodeErrorZ ChannelUpdate_read(struct LDKu8slice ser);
24665 export function ChannelUpdate_read(ser: number): number {
24666 if(!isWasmInitialized) {
24667 throw new Error("initializeWasm() must be awaited first!");
24669 const nativeResponseValue = wasm.TS_ChannelUpdate_read(ser);
24670 return nativeResponseValue;
24672 // struct LDKCVec_u8Z ErrorMessage_write(const struct LDKErrorMessage *NONNULL_PTR obj);
24674 export function ErrorMessage_write(obj: number): number {
24675 if(!isWasmInitialized) {
24676 throw new Error("initializeWasm() must be awaited first!");
24678 const nativeResponseValue = wasm.TS_ErrorMessage_write(obj);
24679 return nativeResponseValue;
24681 // struct LDKCResult_ErrorMessageDecodeErrorZ ErrorMessage_read(struct LDKu8slice ser);
24683 export function ErrorMessage_read(ser: number): number {
24684 if(!isWasmInitialized) {
24685 throw new Error("initializeWasm() must be awaited first!");
24687 const nativeResponseValue = wasm.TS_ErrorMessage_read(ser);
24688 return nativeResponseValue;
24690 // struct LDKCVec_u8Z WarningMessage_write(const struct LDKWarningMessage *NONNULL_PTR obj);
24692 export function WarningMessage_write(obj: number): number {
24693 if(!isWasmInitialized) {
24694 throw new Error("initializeWasm() must be awaited first!");
24696 const nativeResponseValue = wasm.TS_WarningMessage_write(obj);
24697 return nativeResponseValue;
24699 // struct LDKCResult_WarningMessageDecodeErrorZ WarningMessage_read(struct LDKu8slice ser);
24701 export function WarningMessage_read(ser: number): number {
24702 if(!isWasmInitialized) {
24703 throw new Error("initializeWasm() must be awaited first!");
24705 const nativeResponseValue = wasm.TS_WarningMessage_read(ser);
24706 return nativeResponseValue;
24708 // struct LDKCVec_u8Z UnsignedNodeAnnouncement_write(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR obj);
24710 export function UnsignedNodeAnnouncement_write(obj: number): number {
24711 if(!isWasmInitialized) {
24712 throw new Error("initializeWasm() must be awaited first!");
24714 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_write(obj);
24715 return nativeResponseValue;
24717 // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ UnsignedNodeAnnouncement_read(struct LDKu8slice ser);
24719 export function UnsignedNodeAnnouncement_read(ser: number): number {
24720 if(!isWasmInitialized) {
24721 throw new Error("initializeWasm() must be awaited first!");
24723 const nativeResponseValue = wasm.TS_UnsignedNodeAnnouncement_read(ser);
24724 return nativeResponseValue;
24726 // struct LDKCVec_u8Z NodeAnnouncement_write(const struct LDKNodeAnnouncement *NONNULL_PTR obj);
24728 export function NodeAnnouncement_write(obj: number): number {
24729 if(!isWasmInitialized) {
24730 throw new Error("initializeWasm() must be awaited first!");
24732 const nativeResponseValue = wasm.TS_NodeAnnouncement_write(obj);
24733 return nativeResponseValue;
24735 // struct LDKCResult_NodeAnnouncementDecodeErrorZ NodeAnnouncement_read(struct LDKu8slice ser);
24737 export function NodeAnnouncement_read(ser: number): number {
24738 if(!isWasmInitialized) {
24739 throw new Error("initializeWasm() must be awaited first!");
24741 const nativeResponseValue = wasm.TS_NodeAnnouncement_read(ser);
24742 return nativeResponseValue;
24744 // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ QueryShortChannelIds_read(struct LDKu8slice ser);
24746 export function QueryShortChannelIds_read(ser: number): number {
24747 if(!isWasmInitialized) {
24748 throw new Error("initializeWasm() must be awaited first!");
24750 const nativeResponseValue = wasm.TS_QueryShortChannelIds_read(ser);
24751 return nativeResponseValue;
24753 // struct LDKCVec_u8Z QueryShortChannelIds_write(const struct LDKQueryShortChannelIds *NONNULL_PTR obj);
24755 export function QueryShortChannelIds_write(obj: number): number {
24756 if(!isWasmInitialized) {
24757 throw new Error("initializeWasm() must be awaited first!");
24759 const nativeResponseValue = wasm.TS_QueryShortChannelIds_write(obj);
24760 return nativeResponseValue;
24762 // struct LDKCVec_u8Z ReplyShortChannelIdsEnd_write(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR obj);
24764 export function ReplyShortChannelIdsEnd_write(obj: number): number {
24765 if(!isWasmInitialized) {
24766 throw new Error("initializeWasm() must be awaited first!");
24768 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_write(obj);
24769 return nativeResponseValue;
24771 // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ ReplyShortChannelIdsEnd_read(struct LDKu8slice ser);
24773 export function ReplyShortChannelIdsEnd_read(ser: number): number {
24774 if(!isWasmInitialized) {
24775 throw new Error("initializeWasm() must be awaited first!");
24777 const nativeResponseValue = wasm.TS_ReplyShortChannelIdsEnd_read(ser);
24778 return nativeResponseValue;
24780 // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
24782 export function QueryChannelRange_end_blocknum(this_arg: number): number {
24783 if(!isWasmInitialized) {
24784 throw new Error("initializeWasm() must be awaited first!");
24786 const nativeResponseValue = wasm.TS_QueryChannelRange_end_blocknum(this_arg);
24787 return nativeResponseValue;
24789 // struct LDKCVec_u8Z QueryChannelRange_write(const struct LDKQueryChannelRange *NONNULL_PTR obj);
24791 export function QueryChannelRange_write(obj: number): number {
24792 if(!isWasmInitialized) {
24793 throw new Error("initializeWasm() must be awaited first!");
24795 const nativeResponseValue = wasm.TS_QueryChannelRange_write(obj);
24796 return nativeResponseValue;
24798 // struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
24800 export function QueryChannelRange_read(ser: number): number {
24801 if(!isWasmInitialized) {
24802 throw new Error("initializeWasm() must be awaited first!");
24804 const nativeResponseValue = wasm.TS_QueryChannelRange_read(ser);
24805 return nativeResponseValue;
24807 // struct LDKCResult_ReplyChannelRangeDecodeErrorZ ReplyChannelRange_read(struct LDKu8slice ser);
24809 export function ReplyChannelRange_read(ser: number): number {
24810 if(!isWasmInitialized) {
24811 throw new Error("initializeWasm() must be awaited first!");
24813 const nativeResponseValue = wasm.TS_ReplyChannelRange_read(ser);
24814 return nativeResponseValue;
24816 // struct LDKCVec_u8Z ReplyChannelRange_write(const struct LDKReplyChannelRange *NONNULL_PTR obj);
24818 export function ReplyChannelRange_write(obj: number): number {
24819 if(!isWasmInitialized) {
24820 throw new Error("initializeWasm() must be awaited first!");
24822 const nativeResponseValue = wasm.TS_ReplyChannelRange_write(obj);
24823 return nativeResponseValue;
24825 // struct LDKCVec_u8Z GossipTimestampFilter_write(const struct LDKGossipTimestampFilter *NONNULL_PTR obj);
24827 export function GossipTimestampFilter_write(obj: number): number {
24828 if(!isWasmInitialized) {
24829 throw new Error("initializeWasm() must be awaited first!");
24831 const nativeResponseValue = wasm.TS_GossipTimestampFilter_write(obj);
24832 return nativeResponseValue;
24834 // struct LDKCResult_GossipTimestampFilterDecodeErrorZ GossipTimestampFilter_read(struct LDKu8slice ser);
24836 export function GossipTimestampFilter_read(ser: number): number {
24837 if(!isWasmInitialized) {
24838 throw new Error("initializeWasm() must be awaited first!");
24840 const nativeResponseValue = wasm.TS_GossipTimestampFilter_read(ser);
24841 return nativeResponseValue;
24843 // void CustomMessageHandler_free(struct LDKCustomMessageHandler this_ptr);
24845 export function CustomMessageHandler_free(this_ptr: number): void {
24846 if(!isWasmInitialized) {
24847 throw new Error("initializeWasm() must be awaited first!");
24849 const nativeResponseValue = wasm.TS_CustomMessageHandler_free(this_ptr);
24850 // debug statements here
24852 // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
24854 export function IgnoringMessageHandler_free(this_obj: number): void {
24855 if(!isWasmInitialized) {
24856 throw new Error("initializeWasm() must be awaited first!");
24858 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_free(this_obj);
24859 // debug statements here
24861 // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
24863 export function IgnoringMessageHandler_new(): number {
24864 if(!isWasmInitialized) {
24865 throw new Error("initializeWasm() must be awaited first!");
24867 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_new();
24868 return nativeResponseValue;
24870 // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24872 export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
24873 if(!isWasmInitialized) {
24874 throw new Error("initializeWasm() must be awaited first!");
24876 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg);
24877 return nativeResponseValue;
24879 // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24881 export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number {
24882 if(!isWasmInitialized) {
24883 throw new Error("initializeWasm() must be awaited first!");
24885 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
24886 return nativeResponseValue;
24888 // struct LDKCustomMessageReader IgnoringMessageHandler_as_CustomMessageReader(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24890 export function IgnoringMessageHandler_as_CustomMessageReader(this_arg: number): number {
24891 if(!isWasmInitialized) {
24892 throw new Error("initializeWasm() must be awaited first!");
24894 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageReader(this_arg);
24895 return nativeResponseValue;
24897 // struct LDKCustomMessageHandler IgnoringMessageHandler_as_CustomMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg);
24899 export function IgnoringMessageHandler_as_CustomMessageHandler(this_arg: number): number {
24900 if(!isWasmInitialized) {
24901 throw new Error("initializeWasm() must be awaited first!");
24903 const nativeResponseValue = wasm.TS_IgnoringMessageHandler_as_CustomMessageHandler(this_arg);
24904 return nativeResponseValue;
24906 // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
24908 export function ErroringMessageHandler_free(this_obj: number): void {
24909 if(!isWasmInitialized) {
24910 throw new Error("initializeWasm() must be awaited first!");
24912 const nativeResponseValue = wasm.TS_ErroringMessageHandler_free(this_obj);
24913 // debug statements here
24915 // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
24917 export function ErroringMessageHandler_new(): number {
24918 if(!isWasmInitialized) {
24919 throw new Error("initializeWasm() must be awaited first!");
24921 const nativeResponseValue = wasm.TS_ErroringMessageHandler_new();
24922 return nativeResponseValue;
24924 // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
24926 export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number {
24927 if(!isWasmInitialized) {
24928 throw new Error("initializeWasm() must be awaited first!");
24930 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_MessageSendEventsProvider(this_arg);
24931 return nativeResponseValue;
24933 // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg);
24935 export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number {
24936 if(!isWasmInitialized) {
24937 throw new Error("initializeWasm() must be awaited first!");
24939 const nativeResponseValue = wasm.TS_ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
24940 return nativeResponseValue;
24942 // void MessageHandler_free(struct LDKMessageHandler this_obj);
24944 export function MessageHandler_free(this_obj: number): void {
24945 if(!isWasmInitialized) {
24946 throw new Error("initializeWasm() must be awaited first!");
24948 const nativeResponseValue = wasm.TS_MessageHandler_free(this_obj);
24949 // debug statements here
24951 // const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
24953 export function MessageHandler_get_chan_handler(this_ptr: number): number {
24954 if(!isWasmInitialized) {
24955 throw new Error("initializeWasm() must be awaited first!");
24957 const nativeResponseValue = wasm.TS_MessageHandler_get_chan_handler(this_ptr);
24958 return nativeResponseValue;
24960 // void MessageHandler_set_chan_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKChannelMessageHandler val);
24962 export function MessageHandler_set_chan_handler(this_ptr: number, val: number): void {
24963 if(!isWasmInitialized) {
24964 throw new Error("initializeWasm() must be awaited first!");
24966 const nativeResponseValue = wasm.TS_MessageHandler_set_chan_handler(this_ptr, val);
24967 // debug statements here
24969 // const struct LDKRoutingMessageHandler *MessageHandler_get_route_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
24971 export function MessageHandler_get_route_handler(this_ptr: number): number {
24972 if(!isWasmInitialized) {
24973 throw new Error("initializeWasm() must be awaited first!");
24975 const nativeResponseValue = wasm.TS_MessageHandler_get_route_handler(this_ptr);
24976 return nativeResponseValue;
24978 // void MessageHandler_set_route_handler(struct LDKMessageHandler *NONNULL_PTR this_ptr, struct LDKRoutingMessageHandler val);
24980 export function MessageHandler_set_route_handler(this_ptr: number, val: number): void {
24981 if(!isWasmInitialized) {
24982 throw new Error("initializeWasm() must be awaited first!");
24984 const nativeResponseValue = wasm.TS_MessageHandler_set_route_handler(this_ptr, val);
24985 // debug statements here
24987 // MUST_USE_RES struct LDKMessageHandler MessageHandler_new(struct LDKChannelMessageHandler chan_handler_arg, struct LDKRoutingMessageHandler route_handler_arg);
24989 export function MessageHandler_new(chan_handler_arg: number, route_handler_arg: number): number {
24990 if(!isWasmInitialized) {
24991 throw new Error("initializeWasm() must be awaited first!");
24993 const nativeResponseValue = wasm.TS_MessageHandler_new(chan_handler_arg, route_handler_arg);
24994 return nativeResponseValue;
24996 // uintptr_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg);
24998 export function SocketDescriptor_clone_ptr(arg: number): number {
24999 if(!isWasmInitialized) {
25000 throw new Error("initializeWasm() must be awaited first!");
25002 const nativeResponseValue = wasm.TS_SocketDescriptor_clone_ptr(arg);
25003 return nativeResponseValue;
25005 // struct LDKSocketDescriptor SocketDescriptor_clone(const struct LDKSocketDescriptor *NONNULL_PTR orig);
25007 export function SocketDescriptor_clone(orig: number): number {
25008 if(!isWasmInitialized) {
25009 throw new Error("initializeWasm() must be awaited first!");
25011 const nativeResponseValue = wasm.TS_SocketDescriptor_clone(orig);
25012 return nativeResponseValue;
25014 // void SocketDescriptor_free(struct LDKSocketDescriptor this_ptr);
25016 export function SocketDescriptor_free(this_ptr: number): void {
25017 if(!isWasmInitialized) {
25018 throw new Error("initializeWasm() must be awaited first!");
25020 const nativeResponseValue = wasm.TS_SocketDescriptor_free(this_ptr);
25021 // debug statements here
25023 // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
25025 export function PeerHandleError_free(this_obj: number): void {
25026 if(!isWasmInitialized) {
25027 throw new Error("initializeWasm() must be awaited first!");
25029 const nativeResponseValue = wasm.TS_PeerHandleError_free(this_obj);
25030 // debug statements here
25032 // bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
25034 export function PeerHandleError_get_no_connection_possible(this_ptr: number): boolean {
25035 if(!isWasmInitialized) {
25036 throw new Error("initializeWasm() must be awaited first!");
25038 const nativeResponseValue = wasm.TS_PeerHandleError_get_no_connection_possible(this_ptr);
25039 return nativeResponseValue;
25041 // void PeerHandleError_set_no_connection_possible(struct LDKPeerHandleError *NONNULL_PTR this_ptr, bool val);
25043 export function PeerHandleError_set_no_connection_possible(this_ptr: number, val: boolean): void {
25044 if(!isWasmInitialized) {
25045 throw new Error("initializeWasm() must be awaited first!");
25047 const nativeResponseValue = wasm.TS_PeerHandleError_set_no_connection_possible(this_ptr, val);
25048 // debug statements here
25050 // MUST_USE_RES struct LDKPeerHandleError PeerHandleError_new(bool no_connection_possible_arg);
25052 export function PeerHandleError_new(no_connection_possible_arg: boolean): number {
25053 if(!isWasmInitialized) {
25054 throw new Error("initializeWasm() must be awaited first!");
25056 const nativeResponseValue = wasm.TS_PeerHandleError_new(no_connection_possible_arg);
25057 return nativeResponseValue;
25059 // uintptr_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg);
25061 export function PeerHandleError_clone_ptr(arg: number): number {
25062 if(!isWasmInitialized) {
25063 throw new Error("initializeWasm() must be awaited first!");
25065 const nativeResponseValue = wasm.TS_PeerHandleError_clone_ptr(arg);
25066 return nativeResponseValue;
25068 // struct LDKPeerHandleError PeerHandleError_clone(const struct LDKPeerHandleError *NONNULL_PTR orig);
25070 export function PeerHandleError_clone(orig: number): number {
25071 if(!isWasmInitialized) {
25072 throw new Error("initializeWasm() must be awaited first!");
25074 const nativeResponseValue = wasm.TS_PeerHandleError_clone(orig);
25075 return nativeResponseValue;
25077 // void PeerManager_free(struct LDKPeerManager this_obj);
25079 export function PeerManager_free(this_obj: number): void {
25080 if(!isWasmInitialized) {
25081 throw new Error("initializeWasm() must be awaited first!");
25083 const nativeResponseValue = wasm.TS_PeerManager_free(this_obj);
25084 // debug statements here
25086 // 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);
25088 export function PeerManager_new(message_handler: number, our_node_secret: number, ephemeral_random_data: number, logger: number, custom_message_handler: number): number {
25089 if(!isWasmInitialized) {
25090 throw new Error("initializeWasm() must be awaited first!");
25092 const nativeResponseValue = wasm.TS_PeerManager_new(message_handler, our_node_secret, ephemeral_random_data, logger, custom_message_handler);
25093 return nativeResponseValue;
25095 // MUST_USE_RES struct LDKCVec_PublicKeyZ PeerManager_get_peer_node_ids(const struct LDKPeerManager *NONNULL_PTR this_arg);
25097 export function PeerManager_get_peer_node_ids(this_arg: number): number {
25098 if(!isWasmInitialized) {
25099 throw new Error("initializeWasm() must be awaited first!");
25101 const nativeResponseValue = wasm.TS_PeerManager_get_peer_node_ids(this_arg);
25102 return nativeResponseValue;
25104 // 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);
25106 export function PeerManager_new_outbound_connection(this_arg: number, their_node_id: number, descriptor: number, remote_network_address: number): number {
25107 if(!isWasmInitialized) {
25108 throw new Error("initializeWasm() must be awaited first!");
25110 const nativeResponseValue = wasm.TS_PeerManager_new_outbound_connection(this_arg, their_node_id, descriptor, remote_network_address);
25111 return nativeResponseValue;
25113 // 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);
25115 export function PeerManager_new_inbound_connection(this_arg: number, descriptor: number, remote_network_address: number): number {
25116 if(!isWasmInitialized) {
25117 throw new Error("initializeWasm() must be awaited first!");
25119 const nativeResponseValue = wasm.TS_PeerManager_new_inbound_connection(this_arg, descriptor, remote_network_address);
25120 return nativeResponseValue;
25122 // MUST_USE_RES struct LDKCResult_NonePeerHandleErrorZ PeerManager_write_buffer_space_avail(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKSocketDescriptor *NONNULL_PTR descriptor);
25124 export function PeerManager_write_buffer_space_avail(this_arg: number, descriptor: number): number {
25125 if(!isWasmInitialized) {
25126 throw new Error("initializeWasm() must be awaited first!");
25128 const nativeResponseValue = wasm.TS_PeerManager_write_buffer_space_avail(this_arg, descriptor);
25129 return nativeResponseValue;
25131 // 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);
25133 export function PeerManager_read_event(this_arg: number, peer_descriptor: number, data: number): number {
25134 if(!isWasmInitialized) {
25135 throw new Error("initializeWasm() must be awaited first!");
25137 const nativeResponseValue = wasm.TS_PeerManager_read_event(this_arg, peer_descriptor, data);
25138 return nativeResponseValue;
25140 // void PeerManager_process_events(const struct LDKPeerManager *NONNULL_PTR this_arg);
25142 export function PeerManager_process_events(this_arg: number): void {
25143 if(!isWasmInitialized) {
25144 throw new Error("initializeWasm() must be awaited first!");
25146 const nativeResponseValue = wasm.TS_PeerManager_process_events(this_arg);
25147 // debug statements here
25149 // void PeerManager_socket_disconnected(const struct LDKPeerManager *NONNULL_PTR this_arg, const struct LDKSocketDescriptor *NONNULL_PTR descriptor);
25151 export function PeerManager_socket_disconnected(this_arg: number, descriptor: number): void {
25152 if(!isWasmInitialized) {
25153 throw new Error("initializeWasm() must be awaited first!");
25155 const nativeResponseValue = wasm.TS_PeerManager_socket_disconnected(this_arg, descriptor);
25156 // debug statements here
25158 // void PeerManager_disconnect_by_node_id(const struct LDKPeerManager *NONNULL_PTR this_arg, struct LDKPublicKey node_id, bool no_connection_possible);
25160 export function PeerManager_disconnect_by_node_id(this_arg: number, node_id: number, no_connection_possible: boolean): void {
25161 if(!isWasmInitialized) {
25162 throw new Error("initializeWasm() must be awaited first!");
25164 const nativeResponseValue = wasm.TS_PeerManager_disconnect_by_node_id(this_arg, node_id, no_connection_possible);
25165 // debug statements here
25167 // void PeerManager_disconnect_all_peers(const struct LDKPeerManager *NONNULL_PTR this_arg);
25169 export function PeerManager_disconnect_all_peers(this_arg: number): void {
25170 if(!isWasmInitialized) {
25171 throw new Error("initializeWasm() must be awaited first!");
25173 const nativeResponseValue = wasm.TS_PeerManager_disconnect_all_peers(this_arg);
25174 // debug statements here
25176 // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
25178 export function PeerManager_timer_tick_occurred(this_arg: number): void {
25179 if(!isWasmInitialized) {
25180 throw new Error("initializeWasm() must be awaited first!");
25182 const nativeResponseValue = wasm.TS_PeerManager_timer_tick_occurred(this_arg);
25183 // debug statements here
25185 // uint64_t htlc_success_tx_weight(bool opt_anchors);
25187 export function htlc_success_tx_weight(opt_anchors: boolean): bigint {
25188 if(!isWasmInitialized) {
25189 throw new Error("initializeWasm() must be awaited first!");
25191 const nativeResponseValue = wasm.TS_htlc_success_tx_weight(opt_anchors);
25192 return nativeResponseValue;
25194 // uint64_t htlc_timeout_tx_weight(bool opt_anchors);
25196 export function htlc_timeout_tx_weight(opt_anchors: boolean): bigint {
25197 if(!isWasmInitialized) {
25198 throw new Error("initializeWasm() must be awaited first!");
25200 const nativeResponseValue = wasm.TS_htlc_timeout_tx_weight(opt_anchors);
25201 return nativeResponseValue;
25203 // struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
25205 export function build_commitment_secret(commitment_seed: number, idx: bigint): number {
25206 if(!isWasmInitialized) {
25207 throw new Error("initializeWasm() must be awaited first!");
25209 const nativeResponseValue = wasm.TS_build_commitment_secret(commitment_seed, idx);
25210 return nativeResponseValue;
25212 // 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);
25214 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 {
25215 if(!isWasmInitialized) {
25216 throw new Error("initializeWasm() must be awaited first!");
25218 const nativeResponseValue = wasm.TS_build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
25219 return nativeResponseValue;
25221 // void CounterpartyCommitmentSecrets_free(struct LDKCounterpartyCommitmentSecrets this_obj);
25223 export function CounterpartyCommitmentSecrets_free(this_obj: number): void {
25224 if(!isWasmInitialized) {
25225 throw new Error("initializeWasm() must be awaited first!");
25227 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_free(this_obj);
25228 // debug statements here
25230 // uintptr_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg);
25232 export function CounterpartyCommitmentSecrets_clone_ptr(arg: number): number {
25233 if(!isWasmInitialized) {
25234 throw new Error("initializeWasm() must be awaited first!");
25236 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone_ptr(arg);
25237 return nativeResponseValue;
25239 // struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_clone(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR orig);
25241 export function CounterpartyCommitmentSecrets_clone(orig: number): number {
25242 if(!isWasmInitialized) {
25243 throw new Error("initializeWasm() must be awaited first!");
25245 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_clone(orig);
25246 return nativeResponseValue;
25248 // MUST_USE_RES struct LDKCounterpartyCommitmentSecrets CounterpartyCommitmentSecrets_new(void);
25250 export function CounterpartyCommitmentSecrets_new(): number {
25251 if(!isWasmInitialized) {
25252 throw new Error("initializeWasm() must be awaited first!");
25254 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_new();
25255 return nativeResponseValue;
25257 // MUST_USE_RES uint64_t CounterpartyCommitmentSecrets_get_min_seen_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg);
25259 export function CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg: number): bigint {
25260 if(!isWasmInitialized) {
25261 throw new Error("initializeWasm() must be awaited first!");
25263 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_min_seen_secret(this_arg);
25264 return nativeResponseValue;
25266 // MUST_USE_RES struct LDKCResult_NoneNoneZ CounterpartyCommitmentSecrets_provide_secret(struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx, struct LDKThirtyTwoBytes secret);
25268 export function CounterpartyCommitmentSecrets_provide_secret(this_arg: number, idx: bigint, secret: number): number {
25269 if(!isWasmInitialized) {
25270 throw new Error("initializeWasm() must be awaited first!");
25272 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_provide_secret(this_arg, idx, secret);
25273 return nativeResponseValue;
25275 // MUST_USE_RES struct LDKThirtyTwoBytes CounterpartyCommitmentSecrets_get_secret(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR this_arg, uint64_t idx);
25277 export function CounterpartyCommitmentSecrets_get_secret(this_arg: number, idx: bigint): number {
25278 if(!isWasmInitialized) {
25279 throw new Error("initializeWasm() must be awaited first!");
25281 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_get_secret(this_arg, idx);
25282 return nativeResponseValue;
25284 // struct LDKCVec_u8Z CounterpartyCommitmentSecrets_write(const struct LDKCounterpartyCommitmentSecrets *NONNULL_PTR obj);
25286 export function CounterpartyCommitmentSecrets_write(obj: number): number {
25287 if(!isWasmInitialized) {
25288 throw new Error("initializeWasm() must be awaited first!");
25290 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_write(obj);
25291 return nativeResponseValue;
25293 // struct LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ CounterpartyCommitmentSecrets_read(struct LDKu8slice ser);
25295 export function CounterpartyCommitmentSecrets_read(ser: number): number {
25296 if(!isWasmInitialized) {
25297 throw new Error("initializeWasm() must be awaited first!");
25299 const nativeResponseValue = wasm.TS_CounterpartyCommitmentSecrets_read(ser);
25300 return nativeResponseValue;
25302 // struct LDKCResult_SecretKeyErrorZ derive_private_key(struct LDKPublicKey per_commitment_point, const uint8_t (*base_secret)[32]);
25304 export function derive_private_key(per_commitment_point: number, base_secret: number): number {
25305 if(!isWasmInitialized) {
25306 throw new Error("initializeWasm() must be awaited first!");
25308 const nativeResponseValue = wasm.TS_derive_private_key(per_commitment_point, base_secret);
25309 return nativeResponseValue;
25311 // struct LDKCResult_PublicKeyErrorZ derive_public_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey base_point);
25313 export function derive_public_key(per_commitment_point: number, base_point: number): number {
25314 if(!isWasmInitialized) {
25315 throw new Error("initializeWasm() must be awaited first!");
25317 const nativeResponseValue = wasm.TS_derive_public_key(per_commitment_point, base_point);
25318 return nativeResponseValue;
25320 // struct LDKCResult_SecretKeyErrorZ derive_private_revocation_key(const uint8_t (*per_commitment_secret)[32], const uint8_t (*countersignatory_revocation_base_secret)[32]);
25322 export function derive_private_revocation_key(per_commitment_secret: number, countersignatory_revocation_base_secret: number): number {
25323 if(!isWasmInitialized) {
25324 throw new Error("initializeWasm() must be awaited first!");
25326 const nativeResponseValue = wasm.TS_derive_private_revocation_key(per_commitment_secret, countersignatory_revocation_base_secret);
25327 return nativeResponseValue;
25329 // struct LDKCResult_PublicKeyErrorZ derive_public_revocation_key(struct LDKPublicKey per_commitment_point, struct LDKPublicKey countersignatory_revocation_base_point);
25331 export function derive_public_revocation_key(per_commitment_point: number, countersignatory_revocation_base_point: number): number {
25332 if(!isWasmInitialized) {
25333 throw new Error("initializeWasm() must be awaited first!");
25335 const nativeResponseValue = wasm.TS_derive_public_revocation_key(per_commitment_point, countersignatory_revocation_base_point);
25336 return nativeResponseValue;
25338 // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
25340 export function TxCreationKeys_free(this_obj: number): void {
25341 if(!isWasmInitialized) {
25342 throw new Error("initializeWasm() must be awaited first!");
25344 const nativeResponseValue = wasm.TS_TxCreationKeys_free(this_obj);
25345 // debug statements here
25347 // struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25349 export function TxCreationKeys_get_per_commitment_point(this_ptr: number): number {
25350 if(!isWasmInitialized) {
25351 throw new Error("initializeWasm() must be awaited first!");
25353 const nativeResponseValue = wasm.TS_TxCreationKeys_get_per_commitment_point(this_ptr);
25354 return nativeResponseValue;
25356 // void TxCreationKeys_set_per_commitment_point(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25358 export function TxCreationKeys_set_per_commitment_point(this_ptr: number, val: number): void {
25359 if(!isWasmInitialized) {
25360 throw new Error("initializeWasm() must be awaited first!");
25362 const nativeResponseValue = wasm.TS_TxCreationKeys_set_per_commitment_point(this_ptr, val);
25363 // debug statements here
25365 // struct LDKPublicKey TxCreationKeys_get_revocation_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25367 export function TxCreationKeys_get_revocation_key(this_ptr: number): number {
25368 if(!isWasmInitialized) {
25369 throw new Error("initializeWasm() must be awaited first!");
25371 const nativeResponseValue = wasm.TS_TxCreationKeys_get_revocation_key(this_ptr);
25372 return nativeResponseValue;
25374 // void TxCreationKeys_set_revocation_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25376 export function TxCreationKeys_set_revocation_key(this_ptr: number, val: number): void {
25377 if(!isWasmInitialized) {
25378 throw new Error("initializeWasm() must be awaited first!");
25380 const nativeResponseValue = wasm.TS_TxCreationKeys_set_revocation_key(this_ptr, val);
25381 // debug statements here
25383 // struct LDKPublicKey TxCreationKeys_get_broadcaster_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25385 export function TxCreationKeys_get_broadcaster_htlc_key(this_ptr: number): number {
25386 if(!isWasmInitialized) {
25387 throw new Error("initializeWasm() must be awaited first!");
25389 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_htlc_key(this_ptr);
25390 return nativeResponseValue;
25392 // void TxCreationKeys_set_broadcaster_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25394 export function TxCreationKeys_set_broadcaster_htlc_key(this_ptr: number, val: number): void {
25395 if(!isWasmInitialized) {
25396 throw new Error("initializeWasm() must be awaited first!");
25398 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_htlc_key(this_ptr, val);
25399 // debug statements here
25401 // struct LDKPublicKey TxCreationKeys_get_countersignatory_htlc_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25403 export function TxCreationKeys_get_countersignatory_htlc_key(this_ptr: number): number {
25404 if(!isWasmInitialized) {
25405 throw new Error("initializeWasm() must be awaited first!");
25407 const nativeResponseValue = wasm.TS_TxCreationKeys_get_countersignatory_htlc_key(this_ptr);
25408 return nativeResponseValue;
25410 // void TxCreationKeys_set_countersignatory_htlc_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25412 export function TxCreationKeys_set_countersignatory_htlc_key(this_ptr: number, val: number): void {
25413 if(!isWasmInitialized) {
25414 throw new Error("initializeWasm() must be awaited first!");
25416 const nativeResponseValue = wasm.TS_TxCreationKeys_set_countersignatory_htlc_key(this_ptr, val);
25417 // debug statements here
25419 // struct LDKPublicKey TxCreationKeys_get_broadcaster_delayed_payment_key(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
25421 export function TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr: number): number {
25422 if(!isWasmInitialized) {
25423 throw new Error("initializeWasm() must be awaited first!");
25425 const nativeResponseValue = wasm.TS_TxCreationKeys_get_broadcaster_delayed_payment_key(this_ptr);
25426 return nativeResponseValue;
25428 // void TxCreationKeys_set_broadcaster_delayed_payment_key(struct LDKTxCreationKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25430 export function TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr: number, val: number): void {
25431 if(!isWasmInitialized) {
25432 throw new Error("initializeWasm() must be awaited first!");
25434 const nativeResponseValue = wasm.TS_TxCreationKeys_set_broadcaster_delayed_payment_key(this_ptr, val);
25435 // debug statements here
25437 // 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);
25439 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 {
25440 if(!isWasmInitialized) {
25441 throw new Error("initializeWasm() must be awaited first!");
25443 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);
25444 return nativeResponseValue;
25446 // uintptr_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg);
25448 export function TxCreationKeys_clone_ptr(arg: number): number {
25449 if(!isWasmInitialized) {
25450 throw new Error("initializeWasm() must be awaited first!");
25452 const nativeResponseValue = wasm.TS_TxCreationKeys_clone_ptr(arg);
25453 return nativeResponseValue;
25455 // struct LDKTxCreationKeys TxCreationKeys_clone(const struct LDKTxCreationKeys *NONNULL_PTR orig);
25457 export function TxCreationKeys_clone(orig: number): number {
25458 if(!isWasmInitialized) {
25459 throw new Error("initializeWasm() must be awaited first!");
25461 const nativeResponseValue = wasm.TS_TxCreationKeys_clone(orig);
25462 return nativeResponseValue;
25464 // struct LDKCVec_u8Z TxCreationKeys_write(const struct LDKTxCreationKeys *NONNULL_PTR obj);
25466 export function TxCreationKeys_write(obj: number): number {
25467 if(!isWasmInitialized) {
25468 throw new Error("initializeWasm() must be awaited first!");
25470 const nativeResponseValue = wasm.TS_TxCreationKeys_write(obj);
25471 return nativeResponseValue;
25473 // struct LDKCResult_TxCreationKeysDecodeErrorZ TxCreationKeys_read(struct LDKu8slice ser);
25475 export function TxCreationKeys_read(ser: number): number {
25476 if(!isWasmInitialized) {
25477 throw new Error("initializeWasm() must be awaited first!");
25479 const nativeResponseValue = wasm.TS_TxCreationKeys_read(ser);
25480 return nativeResponseValue;
25482 // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
25484 export function ChannelPublicKeys_free(this_obj: number): void {
25485 if(!isWasmInitialized) {
25486 throw new Error("initializeWasm() must be awaited first!");
25488 const nativeResponseValue = wasm.TS_ChannelPublicKeys_free(this_obj);
25489 // debug statements here
25491 // struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25493 export function ChannelPublicKeys_get_funding_pubkey(this_ptr: number): number {
25494 if(!isWasmInitialized) {
25495 throw new Error("initializeWasm() must be awaited first!");
25497 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_funding_pubkey(this_ptr);
25498 return nativeResponseValue;
25500 // void ChannelPublicKeys_set_funding_pubkey(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25502 export function ChannelPublicKeys_set_funding_pubkey(this_ptr: number, val: number): void {
25503 if(!isWasmInitialized) {
25504 throw new Error("initializeWasm() must be awaited first!");
25506 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_funding_pubkey(this_ptr, val);
25507 // debug statements here
25509 // struct LDKPublicKey ChannelPublicKeys_get_revocation_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25511 export function ChannelPublicKeys_get_revocation_basepoint(this_ptr: number): number {
25512 if(!isWasmInitialized) {
25513 throw new Error("initializeWasm() must be awaited first!");
25515 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_revocation_basepoint(this_ptr);
25516 return nativeResponseValue;
25518 // void ChannelPublicKeys_set_revocation_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25520 export function ChannelPublicKeys_set_revocation_basepoint(this_ptr: number, val: number): void {
25521 if(!isWasmInitialized) {
25522 throw new Error("initializeWasm() must be awaited first!");
25524 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_revocation_basepoint(this_ptr, val);
25525 // debug statements here
25527 // struct LDKPublicKey ChannelPublicKeys_get_payment_point(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25529 export function ChannelPublicKeys_get_payment_point(this_ptr: number): number {
25530 if(!isWasmInitialized) {
25531 throw new Error("initializeWasm() must be awaited first!");
25533 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_payment_point(this_ptr);
25534 return nativeResponseValue;
25536 // void ChannelPublicKeys_set_payment_point(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25538 export function ChannelPublicKeys_set_payment_point(this_ptr: number, val: number): void {
25539 if(!isWasmInitialized) {
25540 throw new Error("initializeWasm() must be awaited first!");
25542 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_payment_point(this_ptr, val);
25543 // debug statements here
25545 // struct LDKPublicKey ChannelPublicKeys_get_delayed_payment_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25547 export function ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr: number): number {
25548 if(!isWasmInitialized) {
25549 throw new Error("initializeWasm() must be awaited first!");
25551 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_delayed_payment_basepoint(this_ptr);
25552 return nativeResponseValue;
25554 // void ChannelPublicKeys_set_delayed_payment_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25556 export function ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr: number, val: number): void {
25557 if(!isWasmInitialized) {
25558 throw new Error("initializeWasm() must be awaited first!");
25560 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_delayed_payment_basepoint(this_ptr, val);
25561 // debug statements here
25563 // struct LDKPublicKey ChannelPublicKeys_get_htlc_basepoint(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
25565 export function ChannelPublicKeys_get_htlc_basepoint(this_ptr: number): number {
25566 if(!isWasmInitialized) {
25567 throw new Error("initializeWasm() must be awaited first!");
25569 const nativeResponseValue = wasm.TS_ChannelPublicKeys_get_htlc_basepoint(this_ptr);
25570 return nativeResponseValue;
25572 // void ChannelPublicKeys_set_htlc_basepoint(struct LDKChannelPublicKeys *NONNULL_PTR this_ptr, struct LDKPublicKey val);
25574 export function ChannelPublicKeys_set_htlc_basepoint(this_ptr: number, val: number): void {
25575 if(!isWasmInitialized) {
25576 throw new Error("initializeWasm() must be awaited first!");
25578 const nativeResponseValue = wasm.TS_ChannelPublicKeys_set_htlc_basepoint(this_ptr, val);
25579 // debug statements here
25581 // 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);
25583 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 {
25584 if(!isWasmInitialized) {
25585 throw new Error("initializeWasm() must be awaited first!");
25587 const nativeResponseValue = wasm.TS_ChannelPublicKeys_new(funding_pubkey_arg, revocation_basepoint_arg, payment_point_arg, delayed_payment_basepoint_arg, htlc_basepoint_arg);
25588 return nativeResponseValue;
25590 // uintptr_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg);
25592 export function ChannelPublicKeys_clone_ptr(arg: number): number {
25593 if(!isWasmInitialized) {
25594 throw new Error("initializeWasm() must be awaited first!");
25596 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone_ptr(arg);
25597 return nativeResponseValue;
25599 // struct LDKChannelPublicKeys ChannelPublicKeys_clone(const struct LDKChannelPublicKeys *NONNULL_PTR orig);
25601 export function ChannelPublicKeys_clone(orig: number): number {
25602 if(!isWasmInitialized) {
25603 throw new Error("initializeWasm() must be awaited first!");
25605 const nativeResponseValue = wasm.TS_ChannelPublicKeys_clone(orig);
25606 return nativeResponseValue;
25608 // struct LDKCVec_u8Z ChannelPublicKeys_write(const struct LDKChannelPublicKeys *NONNULL_PTR obj);
25610 export function ChannelPublicKeys_write(obj: number): number {
25611 if(!isWasmInitialized) {
25612 throw new Error("initializeWasm() must be awaited first!");
25614 const nativeResponseValue = wasm.TS_ChannelPublicKeys_write(obj);
25615 return nativeResponseValue;
25617 // struct LDKCResult_ChannelPublicKeysDecodeErrorZ ChannelPublicKeys_read(struct LDKu8slice ser);
25619 export function ChannelPublicKeys_read(ser: number): number {
25620 if(!isWasmInitialized) {
25621 throw new Error("initializeWasm() must be awaited first!");
25623 const nativeResponseValue = wasm.TS_ChannelPublicKeys_read(ser);
25624 return nativeResponseValue;
25626 // 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);
25628 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 {
25629 if(!isWasmInitialized) {
25630 throw new Error("initializeWasm() must be awaited first!");
25632 const nativeResponseValue = wasm.TS_TxCreationKeys_derive_new(per_commitment_point, broadcaster_delayed_payment_base, broadcaster_htlc_base, countersignatory_revocation_base, countersignatory_htlc_base);
25633 return nativeResponseValue;
25635 // 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);
25637 export function TxCreationKeys_from_channel_static_keys(per_commitment_point: number, broadcaster_keys: number, countersignatory_keys: number): number {
25638 if(!isWasmInitialized) {
25639 throw new Error("initializeWasm() must be awaited first!");
25641 const nativeResponseValue = wasm.TS_TxCreationKeys_from_channel_static_keys(per_commitment_point, broadcaster_keys, countersignatory_keys);
25642 return nativeResponseValue;
25644 // struct LDKCVec_u8Z get_revokeable_redeemscript(struct LDKPublicKey revocation_key, uint16_t contest_delay, struct LDKPublicKey broadcaster_delayed_payment_key);
25646 export function get_revokeable_redeemscript(revocation_key: number, contest_delay: number, broadcaster_delayed_payment_key: number): number {
25647 if(!isWasmInitialized) {
25648 throw new Error("initializeWasm() must be awaited first!");
25650 const nativeResponseValue = wasm.TS_get_revokeable_redeemscript(revocation_key, contest_delay, broadcaster_delayed_payment_key);
25651 return nativeResponseValue;
25653 // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
25655 export function HTLCOutputInCommitment_free(this_obj: number): void {
25656 if(!isWasmInitialized) {
25657 throw new Error("initializeWasm() must be awaited first!");
25659 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_free(this_obj);
25660 // debug statements here
25662 // bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25664 export function HTLCOutputInCommitment_get_offered(this_ptr: number): boolean {
25665 if(!isWasmInitialized) {
25666 throw new Error("initializeWasm() must be awaited first!");
25668 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_offered(this_ptr);
25669 return nativeResponseValue;
25671 // void HTLCOutputInCommitment_set_offered(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, bool val);
25673 export function HTLCOutputInCommitment_set_offered(this_ptr: number, val: boolean): void {
25674 if(!isWasmInitialized) {
25675 throw new Error("initializeWasm() must be awaited first!");
25677 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_offered(this_ptr, val);
25678 // debug statements here
25680 // uint64_t HTLCOutputInCommitment_get_amount_msat(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25682 export function HTLCOutputInCommitment_get_amount_msat(this_ptr: number): bigint {
25683 if(!isWasmInitialized) {
25684 throw new Error("initializeWasm() must be awaited first!");
25686 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_amount_msat(this_ptr);
25687 return nativeResponseValue;
25689 // void HTLCOutputInCommitment_set_amount_msat(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint64_t val);
25691 export function HTLCOutputInCommitment_set_amount_msat(this_ptr: number, val: bigint): void {
25692 if(!isWasmInitialized) {
25693 throw new Error("initializeWasm() must be awaited first!");
25695 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_amount_msat(this_ptr, val);
25696 // debug statements here
25698 // uint32_t HTLCOutputInCommitment_get_cltv_expiry(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25700 export function HTLCOutputInCommitment_get_cltv_expiry(this_ptr: number): number {
25701 if(!isWasmInitialized) {
25702 throw new Error("initializeWasm() must be awaited first!");
25704 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_cltv_expiry(this_ptr);
25705 return nativeResponseValue;
25707 // void HTLCOutputInCommitment_set_cltv_expiry(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, uint32_t val);
25709 export function HTLCOutputInCommitment_set_cltv_expiry(this_ptr: number, val: number): void {
25710 if(!isWasmInitialized) {
25711 throw new Error("initializeWasm() must be awaited first!");
25713 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_cltv_expiry(this_ptr, val);
25714 // debug statements here
25716 // const uint8_t (*HTLCOutputInCommitment_get_payment_hash(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr))[32];
25718 export function HTLCOutputInCommitment_get_payment_hash(this_ptr: number): number {
25719 if(!isWasmInitialized) {
25720 throw new Error("initializeWasm() must be awaited first!");
25722 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_payment_hash(this_ptr);
25723 return nativeResponseValue;
25725 // void HTLCOutputInCommitment_set_payment_hash(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
25727 export function HTLCOutputInCommitment_set_payment_hash(this_ptr: number, val: number): void {
25728 if(!isWasmInitialized) {
25729 throw new Error("initializeWasm() must be awaited first!");
25731 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_payment_hash(this_ptr, val);
25732 // debug statements here
25734 // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
25736 export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
25737 if(!isWasmInitialized) {
25738 throw new Error("initializeWasm() must be awaited first!");
25740 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
25741 return nativeResponseValue;
25743 // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
25745 export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: number, val: number): void {
25746 if(!isWasmInitialized) {
25747 throw new Error("initializeWasm() must be awaited first!");
25749 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
25750 // debug statements here
25752 // 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);
25754 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 {
25755 if(!isWasmInitialized) {
25756 throw new Error("initializeWasm() must be awaited first!");
25758 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg, transaction_output_index_arg);
25759 return nativeResponseValue;
25761 // uintptr_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg);
25763 export function HTLCOutputInCommitment_clone_ptr(arg: number): number {
25764 if(!isWasmInitialized) {
25765 throw new Error("initializeWasm() must be awaited first!");
25767 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone_ptr(arg);
25768 return nativeResponseValue;
25770 // struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
25772 export function HTLCOutputInCommitment_clone(orig: number): number {
25773 if(!isWasmInitialized) {
25774 throw new Error("initializeWasm() must be awaited first!");
25776 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_clone(orig);
25777 return nativeResponseValue;
25779 // struct LDKCVec_u8Z HTLCOutputInCommitment_write(const struct LDKHTLCOutputInCommitment *NONNULL_PTR obj);
25781 export function HTLCOutputInCommitment_write(obj: number): number {
25782 if(!isWasmInitialized) {
25783 throw new Error("initializeWasm() must be awaited first!");
25785 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_write(obj);
25786 return nativeResponseValue;
25788 // struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ HTLCOutputInCommitment_read(struct LDKu8slice ser);
25790 export function HTLCOutputInCommitment_read(ser: number): number {
25791 if(!isWasmInitialized) {
25792 throw new Error("initializeWasm() must be awaited first!");
25794 const nativeResponseValue = wasm.TS_HTLCOutputInCommitment_read(ser);
25795 return nativeResponseValue;
25797 // struct LDKCVec_u8Z get_htlc_redeemscript(const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc, bool opt_anchors, const struct LDKTxCreationKeys *NONNULL_PTR keys);
25799 export function get_htlc_redeemscript(htlc: number, opt_anchors: boolean, keys: number): number {
25800 if(!isWasmInitialized) {
25801 throw new Error("initializeWasm() must be awaited first!");
25803 const nativeResponseValue = wasm.TS_get_htlc_redeemscript(htlc, opt_anchors, keys);
25804 return nativeResponseValue;
25806 // struct LDKCVec_u8Z make_funding_redeemscript(struct LDKPublicKey broadcaster, struct LDKPublicKey countersignatory);
25808 export function make_funding_redeemscript(broadcaster: number, countersignatory: number): number {
25809 if(!isWasmInitialized) {
25810 throw new Error("initializeWasm() must be awaited first!");
25812 const nativeResponseValue = wasm.TS_make_funding_redeemscript(broadcaster, countersignatory);
25813 return nativeResponseValue;
25815 // 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);
25817 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 {
25818 if(!isWasmInitialized) {
25819 throw new Error("initializeWasm() must be awaited first!");
25821 const nativeResponseValue = wasm.TS_build_htlc_transaction(commitment_txid, feerate_per_kw, contest_delay, htlc, opt_anchors, broadcaster_delayed_payment_key, revocation_key);
25822 return nativeResponseValue;
25824 // struct LDKCVec_u8Z get_anchor_redeemscript(struct LDKPublicKey funding_pubkey);
25826 export function get_anchor_redeemscript(funding_pubkey: number): number {
25827 if(!isWasmInitialized) {
25828 throw new Error("initializeWasm() must be awaited first!");
25830 const nativeResponseValue = wasm.TS_get_anchor_redeemscript(funding_pubkey);
25831 return nativeResponseValue;
25833 // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
25835 export function ChannelTransactionParameters_free(this_obj: number): void {
25836 if(!isWasmInitialized) {
25837 throw new Error("initializeWasm() must be awaited first!");
25839 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_free(this_obj);
25840 // debug statements here
25842 // struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25844 export function ChannelTransactionParameters_get_holder_pubkeys(this_ptr: number): number {
25845 if(!isWasmInitialized) {
25846 throw new Error("initializeWasm() must be awaited first!");
25848 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_pubkeys(this_ptr);
25849 return nativeResponseValue;
25851 // void ChannelTransactionParameters_set_holder_pubkeys(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
25853 export function ChannelTransactionParameters_set_holder_pubkeys(this_ptr: number, val: number): void {
25854 if(!isWasmInitialized) {
25855 throw new Error("initializeWasm() must be awaited first!");
25857 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_pubkeys(this_ptr, val);
25858 // debug statements here
25860 // uint16_t ChannelTransactionParameters_get_holder_selected_contest_delay(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25862 export function ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr: number): number {
25863 if(!isWasmInitialized) {
25864 throw new Error("initializeWasm() must be awaited first!");
25866 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_holder_selected_contest_delay(this_ptr);
25867 return nativeResponseValue;
25869 // void ChannelTransactionParameters_set_holder_selected_contest_delay(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
25871 export function ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr: number, val: number): void {
25872 if(!isWasmInitialized) {
25873 throw new Error("initializeWasm() must be awaited first!");
25875 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_holder_selected_contest_delay(this_ptr, val);
25876 // debug statements here
25878 // bool ChannelTransactionParameters_get_is_outbound_from_holder(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25880 export function ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr: number): boolean {
25881 if(!isWasmInitialized) {
25882 throw new Error("initializeWasm() must be awaited first!");
25884 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_is_outbound_from_holder(this_ptr);
25885 return nativeResponseValue;
25887 // void ChannelTransactionParameters_set_is_outbound_from_holder(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, bool val);
25889 export function ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr: number, val: boolean): void {
25890 if(!isWasmInitialized) {
25891 throw new Error("initializeWasm() must be awaited first!");
25893 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_is_outbound_from_holder(this_ptr, val);
25894 // debug statements here
25896 // struct LDKCounterpartyChannelTransactionParameters ChannelTransactionParameters_get_counterparty_parameters(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25898 export function ChannelTransactionParameters_get_counterparty_parameters(this_ptr: number): number {
25899 if(!isWasmInitialized) {
25900 throw new Error("initializeWasm() must be awaited first!");
25902 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_counterparty_parameters(this_ptr);
25903 return nativeResponseValue;
25905 // void ChannelTransactionParameters_set_counterparty_parameters(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKCounterpartyChannelTransactionParameters val);
25907 export function ChannelTransactionParameters_set_counterparty_parameters(this_ptr: number, val: number): void {
25908 if(!isWasmInitialized) {
25909 throw new Error("initializeWasm() must be awaited first!");
25911 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_counterparty_parameters(this_ptr, val);
25912 // debug statements here
25914 // struct LDKOutPoint ChannelTransactionParameters_get_funding_outpoint(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25916 export function ChannelTransactionParameters_get_funding_outpoint(this_ptr: number): number {
25917 if(!isWasmInitialized) {
25918 throw new Error("initializeWasm() must be awaited first!");
25920 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_funding_outpoint(this_ptr);
25921 return nativeResponseValue;
25923 // void ChannelTransactionParameters_set_funding_outpoint(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKOutPoint val);
25925 export function ChannelTransactionParameters_set_funding_outpoint(this_ptr: number, val: number): void {
25926 if(!isWasmInitialized) {
25927 throw new Error("initializeWasm() must be awaited first!");
25929 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_funding_outpoint(this_ptr, val);
25930 // debug statements here
25932 // enum LDKCOption_NoneZ ChannelTransactionParameters_get_opt_anchors(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
25934 export function ChannelTransactionParameters_get_opt_anchors(this_ptr: number): COption_NoneZ {
25935 if(!isWasmInitialized) {
25936 throw new Error("initializeWasm() must be awaited first!");
25938 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_get_opt_anchors(this_ptr);
25939 return nativeResponseValue;
25941 // void ChannelTransactionParameters_set_opt_anchors(struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr, enum LDKCOption_NoneZ val);
25943 export function ChannelTransactionParameters_set_opt_anchors(this_ptr: number, val: COption_NoneZ): void {
25944 if(!isWasmInitialized) {
25945 throw new Error("initializeWasm() must be awaited first!");
25947 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_set_opt_anchors(this_ptr, val);
25948 // debug statements here
25950 // 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);
25952 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 {
25953 if(!isWasmInitialized) {
25954 throw new Error("initializeWasm() must be awaited first!");
25956 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);
25957 return nativeResponseValue;
25959 // uintptr_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg);
25961 export function ChannelTransactionParameters_clone_ptr(arg: number): number {
25962 if(!isWasmInitialized) {
25963 throw new Error("initializeWasm() must be awaited first!");
25965 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone_ptr(arg);
25966 return nativeResponseValue;
25968 // struct LDKChannelTransactionParameters ChannelTransactionParameters_clone(const struct LDKChannelTransactionParameters *NONNULL_PTR orig);
25970 export function ChannelTransactionParameters_clone(orig: number): number {
25971 if(!isWasmInitialized) {
25972 throw new Error("initializeWasm() must be awaited first!");
25974 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_clone(orig);
25975 return nativeResponseValue;
25977 // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
25979 export function CounterpartyChannelTransactionParameters_free(this_obj: number): void {
25980 if(!isWasmInitialized) {
25981 throw new Error("initializeWasm() must be awaited first!");
25983 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_free(this_obj);
25984 // debug statements here
25986 // struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
25988 export function CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr: number): number {
25989 if(!isWasmInitialized) {
25990 throw new Error("initializeWasm() must be awaited first!");
25992 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_pubkeys(this_ptr);
25993 return nativeResponseValue;
25995 // void CounterpartyChannelTransactionParameters_set_pubkeys(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, struct LDKChannelPublicKeys val);
25997 export function CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr: number, val: number): void {
25998 if(!isWasmInitialized) {
25999 throw new Error("initializeWasm() must be awaited first!");
26001 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_pubkeys(this_ptr, val);
26002 // debug statements here
26004 // uint16_t CounterpartyChannelTransactionParameters_get_selected_contest_delay(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
26006 export function CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr: number): number {
26007 if(!isWasmInitialized) {
26008 throw new Error("initializeWasm() must be awaited first!");
26010 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(this_ptr);
26011 return nativeResponseValue;
26013 // void CounterpartyChannelTransactionParameters_set_selected_contest_delay(struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr, uint16_t val);
26015 export function CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr: number, val: number): void {
26016 if(!isWasmInitialized) {
26017 throw new Error("initializeWasm() must be awaited first!");
26019 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(this_ptr, val);
26020 // debug statements here
26022 // MUST_USE_RES struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_new(struct LDKChannelPublicKeys pubkeys_arg, uint16_t selected_contest_delay_arg);
26024 export function CounterpartyChannelTransactionParameters_new(pubkeys_arg: number, selected_contest_delay_arg: number): number {
26025 if(!isWasmInitialized) {
26026 throw new Error("initializeWasm() must be awaited first!");
26028 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_new(pubkeys_arg, selected_contest_delay_arg);
26029 return nativeResponseValue;
26031 // uintptr_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg);
26033 export function CounterpartyChannelTransactionParameters_clone_ptr(arg: number): number {
26034 if(!isWasmInitialized) {
26035 throw new Error("initializeWasm() must be awaited first!");
26037 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone_ptr(arg);
26038 return nativeResponseValue;
26040 // struct LDKCounterpartyChannelTransactionParameters CounterpartyChannelTransactionParameters_clone(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR orig);
26042 export function CounterpartyChannelTransactionParameters_clone(orig: number): number {
26043 if(!isWasmInitialized) {
26044 throw new Error("initializeWasm() must be awaited first!");
26046 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_clone(orig);
26047 return nativeResponseValue;
26049 // MUST_USE_RES bool ChannelTransactionParameters_is_populated(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26051 export function ChannelTransactionParameters_is_populated(this_arg: number): boolean {
26052 if(!isWasmInitialized) {
26053 throw new Error("initializeWasm() must be awaited first!");
26055 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_is_populated(this_arg);
26056 return nativeResponseValue;
26058 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_holder_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26060 export function ChannelTransactionParameters_as_holder_broadcastable(this_arg: number): number {
26061 if(!isWasmInitialized) {
26062 throw new Error("initializeWasm() must be awaited first!");
26064 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_holder_broadcastable(this_arg);
26065 return nativeResponseValue;
26067 // MUST_USE_RES struct LDKDirectedChannelTransactionParameters ChannelTransactionParameters_as_counterparty_broadcastable(const struct LDKChannelTransactionParameters *NONNULL_PTR this_arg);
26069 export function ChannelTransactionParameters_as_counterparty_broadcastable(this_arg: number): number {
26070 if(!isWasmInitialized) {
26071 throw new Error("initializeWasm() must be awaited first!");
26073 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_as_counterparty_broadcastable(this_arg);
26074 return nativeResponseValue;
26076 // struct LDKCVec_u8Z CounterpartyChannelTransactionParameters_write(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR obj);
26078 export function CounterpartyChannelTransactionParameters_write(obj: number): number {
26079 if(!isWasmInitialized) {
26080 throw new Error("initializeWasm() must be awaited first!");
26082 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_write(obj);
26083 return nativeResponseValue;
26085 // struct LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ CounterpartyChannelTransactionParameters_read(struct LDKu8slice ser);
26087 export function CounterpartyChannelTransactionParameters_read(ser: number): number {
26088 if(!isWasmInitialized) {
26089 throw new Error("initializeWasm() must be awaited first!");
26091 const nativeResponseValue = wasm.TS_CounterpartyChannelTransactionParameters_read(ser);
26092 return nativeResponseValue;
26094 // struct LDKCVec_u8Z ChannelTransactionParameters_write(const struct LDKChannelTransactionParameters *NONNULL_PTR obj);
26096 export function ChannelTransactionParameters_write(obj: number): number {
26097 if(!isWasmInitialized) {
26098 throw new Error("initializeWasm() must be awaited first!");
26100 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_write(obj);
26101 return nativeResponseValue;
26103 // struct LDKCResult_ChannelTransactionParametersDecodeErrorZ ChannelTransactionParameters_read(struct LDKu8slice ser);
26105 export function ChannelTransactionParameters_read(ser: number): number {
26106 if(!isWasmInitialized) {
26107 throw new Error("initializeWasm() must be awaited first!");
26109 const nativeResponseValue = wasm.TS_ChannelTransactionParameters_read(ser);
26110 return nativeResponseValue;
26112 // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
26114 export function DirectedChannelTransactionParameters_free(this_obj: number): void {
26115 if(!isWasmInitialized) {
26116 throw new Error("initializeWasm() must be awaited first!");
26118 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_free(this_obj);
26119 // debug statements here
26121 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26123 export function DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg: number): number {
26124 if(!isWasmInitialized) {
26125 throw new Error("initializeWasm() must be awaited first!");
26127 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(this_arg);
26128 return nativeResponseValue;
26130 // MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_countersignatory_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26132 export function DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg: number): number {
26133 if(!isWasmInitialized) {
26134 throw new Error("initializeWasm() must be awaited first!");
26136 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(this_arg);
26137 return nativeResponseValue;
26139 // MUST_USE_RES uint16_t DirectedChannelTransactionParameters_contest_delay(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26141 export function DirectedChannelTransactionParameters_contest_delay(this_arg: number): number {
26142 if(!isWasmInitialized) {
26143 throw new Error("initializeWasm() must be awaited first!");
26145 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_contest_delay(this_arg);
26146 return nativeResponseValue;
26148 // MUST_USE_RES bool DirectedChannelTransactionParameters_is_outbound(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26150 export function DirectedChannelTransactionParameters_is_outbound(this_arg: number): boolean {
26151 if(!isWasmInitialized) {
26152 throw new Error("initializeWasm() must be awaited first!");
26154 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_is_outbound(this_arg);
26155 return nativeResponseValue;
26157 // MUST_USE_RES struct LDKOutPoint DirectedChannelTransactionParameters_funding_outpoint(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26159 export function DirectedChannelTransactionParameters_funding_outpoint(this_arg: number): number {
26160 if(!isWasmInitialized) {
26161 throw new Error("initializeWasm() must be awaited first!");
26163 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_funding_outpoint(this_arg);
26164 return nativeResponseValue;
26166 // MUST_USE_RES bool DirectedChannelTransactionParameters_opt_anchors(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
26168 export function DirectedChannelTransactionParameters_opt_anchors(this_arg: number): boolean {
26169 if(!isWasmInitialized) {
26170 throw new Error("initializeWasm() must be awaited first!");
26172 const nativeResponseValue = wasm.TS_DirectedChannelTransactionParameters_opt_anchors(this_arg);
26173 return nativeResponseValue;
26175 // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
26177 export function HolderCommitmentTransaction_free(this_obj: number): void {
26178 if(!isWasmInitialized) {
26179 throw new Error("initializeWasm() must be awaited first!");
26181 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_free(this_obj);
26182 // debug statements here
26184 // struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
26186 export function HolderCommitmentTransaction_get_counterparty_sig(this_ptr: number): number {
26187 if(!isWasmInitialized) {
26188 throw new Error("initializeWasm() must be awaited first!");
26190 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_get_counterparty_sig(this_ptr);
26191 return nativeResponseValue;
26193 // void HolderCommitmentTransaction_set_counterparty_sig(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKSignature val);
26195 export function HolderCommitmentTransaction_set_counterparty_sig(this_ptr: number, val: number): void {
26196 if(!isWasmInitialized) {
26197 throw new Error("initializeWasm() must be awaited first!");
26199 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_sig(this_ptr, val);
26200 // debug statements here
26202 // void HolderCommitmentTransaction_set_counterparty_htlc_sigs(struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKCVec_SignatureZ val);
26204 export function HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr: number, val: number): void {
26205 if(!isWasmInitialized) {
26206 throw new Error("initializeWasm() must be awaited first!");
26208 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(this_ptr, val);
26209 // debug statements here
26211 // uintptr_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg);
26213 export function HolderCommitmentTransaction_clone_ptr(arg: number): number {
26214 if(!isWasmInitialized) {
26215 throw new Error("initializeWasm() must be awaited first!");
26217 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone_ptr(arg);
26218 return nativeResponseValue;
26220 // struct LDKHolderCommitmentTransaction HolderCommitmentTransaction_clone(const struct LDKHolderCommitmentTransaction *NONNULL_PTR orig);
26222 export function HolderCommitmentTransaction_clone(orig: number): number {
26223 if(!isWasmInitialized) {
26224 throw new Error("initializeWasm() must be awaited first!");
26226 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_clone(orig);
26227 return nativeResponseValue;
26229 // struct LDKCVec_u8Z HolderCommitmentTransaction_write(const struct LDKHolderCommitmentTransaction *NONNULL_PTR obj);
26231 export function HolderCommitmentTransaction_write(obj: number): number {
26232 if(!isWasmInitialized) {
26233 throw new Error("initializeWasm() must be awaited first!");
26235 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_write(obj);
26236 return nativeResponseValue;
26238 // struct LDKCResult_HolderCommitmentTransactionDecodeErrorZ HolderCommitmentTransaction_read(struct LDKu8slice ser);
26240 export function HolderCommitmentTransaction_read(ser: number): number {
26241 if(!isWasmInitialized) {
26242 throw new Error("initializeWasm() must be awaited first!");
26244 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_read(ser);
26245 return nativeResponseValue;
26247 // 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);
26249 export function HolderCommitmentTransaction_new(commitment_tx: number, counterparty_sig: number, counterparty_htlc_sigs: number, holder_funding_key: number, counterparty_funding_key: number): number {
26250 if(!isWasmInitialized) {
26251 throw new Error("initializeWasm() must be awaited first!");
26253 const nativeResponseValue = wasm.TS_HolderCommitmentTransaction_new(commitment_tx, counterparty_sig, counterparty_htlc_sigs, holder_funding_key, counterparty_funding_key);
26254 return nativeResponseValue;
26256 // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
26258 export function BuiltCommitmentTransaction_free(this_obj: number): void {
26259 if(!isWasmInitialized) {
26260 throw new Error("initializeWasm() must be awaited first!");
26262 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_free(this_obj);
26263 // debug statements here
26265 // struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
26267 export function BuiltCommitmentTransaction_get_transaction(this_ptr: number): number {
26268 if(!isWasmInitialized) {
26269 throw new Error("initializeWasm() must be awaited first!");
26271 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_transaction(this_ptr);
26272 return nativeResponseValue;
26274 // void BuiltCommitmentTransaction_set_transaction(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKTransaction val);
26276 export function BuiltCommitmentTransaction_set_transaction(this_ptr: number, val: number): void {
26277 if(!isWasmInitialized) {
26278 throw new Error("initializeWasm() must be awaited first!");
26280 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_transaction(this_ptr, val);
26281 // debug statements here
26283 // const uint8_t (*BuiltCommitmentTransaction_get_txid(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr))[32];
26285 export function BuiltCommitmentTransaction_get_txid(this_ptr: number): number {
26286 if(!isWasmInitialized) {
26287 throw new Error("initializeWasm() must be awaited first!");
26289 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_txid(this_ptr);
26290 return nativeResponseValue;
26292 // void BuiltCommitmentTransaction_set_txid(struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
26294 export function BuiltCommitmentTransaction_set_txid(this_ptr: number, val: number): void {
26295 if(!isWasmInitialized) {
26296 throw new Error("initializeWasm() must be awaited first!");
26298 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_set_txid(this_ptr, val);
26299 // debug statements here
26301 // MUST_USE_RES struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_new(struct LDKTransaction transaction_arg, struct LDKThirtyTwoBytes txid_arg);
26303 export function BuiltCommitmentTransaction_new(transaction_arg: number, txid_arg: number): number {
26304 if(!isWasmInitialized) {
26305 throw new Error("initializeWasm() must be awaited first!");
26307 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_new(transaction_arg, txid_arg);
26308 return nativeResponseValue;
26310 // uintptr_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg);
26312 export function BuiltCommitmentTransaction_clone_ptr(arg: number): number {
26313 if(!isWasmInitialized) {
26314 throw new Error("initializeWasm() must be awaited first!");
26316 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone_ptr(arg);
26317 return nativeResponseValue;
26319 // struct LDKBuiltCommitmentTransaction BuiltCommitmentTransaction_clone(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR orig);
26321 export function BuiltCommitmentTransaction_clone(orig: number): number {
26322 if(!isWasmInitialized) {
26323 throw new Error("initializeWasm() must be awaited first!");
26325 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_clone(orig);
26326 return nativeResponseValue;
26328 // struct LDKCVec_u8Z BuiltCommitmentTransaction_write(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR obj);
26330 export function BuiltCommitmentTransaction_write(obj: number): number {
26331 if(!isWasmInitialized) {
26332 throw new Error("initializeWasm() must be awaited first!");
26334 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_write(obj);
26335 return nativeResponseValue;
26337 // struct LDKCResult_BuiltCommitmentTransactionDecodeErrorZ BuiltCommitmentTransaction_read(struct LDKu8slice ser);
26339 export function BuiltCommitmentTransaction_read(ser: number): number {
26340 if(!isWasmInitialized) {
26341 throw new Error("initializeWasm() must be awaited first!");
26343 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_read(ser);
26344 return nativeResponseValue;
26346 // 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);
26348 export function BuiltCommitmentTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26349 if(!isWasmInitialized) {
26350 throw new Error("initializeWasm() must be awaited first!");
26352 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
26353 return nativeResponseValue;
26355 // 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);
26357 export function BuiltCommitmentTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26358 if(!isWasmInitialized) {
26359 throw new Error("initializeWasm() must be awaited first!");
26361 const nativeResponseValue = wasm.TS_BuiltCommitmentTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
26362 return nativeResponseValue;
26364 // void ClosingTransaction_free(struct LDKClosingTransaction this_obj);
26366 export function ClosingTransaction_free(this_obj: number): void {
26367 if(!isWasmInitialized) {
26368 throw new Error("initializeWasm() must be awaited first!");
26370 const nativeResponseValue = wasm.TS_ClosingTransaction_free(this_obj);
26371 // debug statements here
26373 // uintptr_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg);
26375 export function ClosingTransaction_clone_ptr(arg: number): number {
26376 if(!isWasmInitialized) {
26377 throw new Error("initializeWasm() must be awaited first!");
26379 const nativeResponseValue = wasm.TS_ClosingTransaction_clone_ptr(arg);
26380 return nativeResponseValue;
26382 // struct LDKClosingTransaction ClosingTransaction_clone(const struct LDKClosingTransaction *NONNULL_PTR orig);
26384 export function ClosingTransaction_clone(orig: number): number {
26385 if(!isWasmInitialized) {
26386 throw new Error("initializeWasm() must be awaited first!");
26388 const nativeResponseValue = wasm.TS_ClosingTransaction_clone(orig);
26389 return nativeResponseValue;
26391 // uint64_t ClosingTransaction_hash(const struct LDKClosingTransaction *NONNULL_PTR o);
26393 export function ClosingTransaction_hash(o: number): bigint {
26394 if(!isWasmInitialized) {
26395 throw new Error("initializeWasm() must be awaited first!");
26397 const nativeResponseValue = wasm.TS_ClosingTransaction_hash(o);
26398 return nativeResponseValue;
26400 // 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);
26402 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 {
26403 if(!isWasmInitialized) {
26404 throw new Error("initializeWasm() must be awaited first!");
26406 const nativeResponseValue = wasm.TS_ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script, to_counterparty_script, funding_outpoint);
26407 return nativeResponseValue;
26409 // MUST_USE_RES struct LDKTrustedClosingTransaction ClosingTransaction_trust(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26411 export function ClosingTransaction_trust(this_arg: number): number {
26412 if(!isWasmInitialized) {
26413 throw new Error("initializeWasm() must be awaited first!");
26415 const nativeResponseValue = wasm.TS_ClosingTransaction_trust(this_arg);
26416 return nativeResponseValue;
26418 // MUST_USE_RES struct LDKCResult_TrustedClosingTransactionNoneZ ClosingTransaction_verify(const struct LDKClosingTransaction *NONNULL_PTR this_arg, struct LDKOutPoint funding_outpoint);
26420 export function ClosingTransaction_verify(this_arg: number, funding_outpoint: number): number {
26421 if(!isWasmInitialized) {
26422 throw new Error("initializeWasm() must be awaited first!");
26424 const nativeResponseValue = wasm.TS_ClosingTransaction_verify(this_arg, funding_outpoint);
26425 return nativeResponseValue;
26427 // MUST_USE_RES uint64_t ClosingTransaction_to_holder_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26429 export function ClosingTransaction_to_holder_value_sat(this_arg: number): bigint {
26430 if(!isWasmInitialized) {
26431 throw new Error("initializeWasm() must be awaited first!");
26433 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_value_sat(this_arg);
26434 return nativeResponseValue;
26436 // MUST_USE_RES uint64_t ClosingTransaction_to_counterparty_value_sat(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26438 export function ClosingTransaction_to_counterparty_value_sat(this_arg: number): bigint {
26439 if(!isWasmInitialized) {
26440 throw new Error("initializeWasm() must be awaited first!");
26442 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_value_sat(this_arg);
26443 return nativeResponseValue;
26445 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_holder_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26447 export function ClosingTransaction_to_holder_script(this_arg: number): number {
26448 if(!isWasmInitialized) {
26449 throw new Error("initializeWasm() must be awaited first!");
26451 const nativeResponseValue = wasm.TS_ClosingTransaction_to_holder_script(this_arg);
26452 return nativeResponseValue;
26454 // MUST_USE_RES struct LDKu8slice ClosingTransaction_to_counterparty_script(const struct LDKClosingTransaction *NONNULL_PTR this_arg);
26456 export function ClosingTransaction_to_counterparty_script(this_arg: number): number {
26457 if(!isWasmInitialized) {
26458 throw new Error("initializeWasm() must be awaited first!");
26460 const nativeResponseValue = wasm.TS_ClosingTransaction_to_counterparty_script(this_arg);
26461 return nativeResponseValue;
26463 // void TrustedClosingTransaction_free(struct LDKTrustedClosingTransaction this_obj);
26465 export function TrustedClosingTransaction_free(this_obj: number): void {
26466 if(!isWasmInitialized) {
26467 throw new Error("initializeWasm() must be awaited first!");
26469 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_free(this_obj);
26470 // debug statements here
26472 // MUST_USE_RES struct LDKTransaction TrustedClosingTransaction_built_transaction(const struct LDKTrustedClosingTransaction *NONNULL_PTR this_arg);
26474 export function TrustedClosingTransaction_built_transaction(this_arg: number): number {
26475 if(!isWasmInitialized) {
26476 throw new Error("initializeWasm() must be awaited first!");
26478 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_built_transaction(this_arg);
26479 return nativeResponseValue;
26481 // 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);
26483 export function TrustedClosingTransaction_get_sighash_all(this_arg: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26484 if(!isWasmInitialized) {
26485 throw new Error("initializeWasm() must be awaited first!");
26487 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_get_sighash_all(this_arg, funding_redeemscript, channel_value_satoshis);
26488 return nativeResponseValue;
26490 // 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);
26492 export function TrustedClosingTransaction_sign(this_arg: number, funding_key: number, funding_redeemscript: number, channel_value_satoshis: bigint): number {
26493 if(!isWasmInitialized) {
26494 throw new Error("initializeWasm() must be awaited first!");
26496 const nativeResponseValue = wasm.TS_TrustedClosingTransaction_sign(this_arg, funding_key, funding_redeemscript, channel_value_satoshis);
26497 return nativeResponseValue;
26499 // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
26501 export function CommitmentTransaction_free(this_obj: number): void {
26502 if(!isWasmInitialized) {
26503 throw new Error("initializeWasm() must be awaited first!");
26505 const nativeResponseValue = wasm.TS_CommitmentTransaction_free(this_obj);
26506 // debug statements here
26508 // uintptr_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg);
26510 export function CommitmentTransaction_clone_ptr(arg: number): number {
26511 if(!isWasmInitialized) {
26512 throw new Error("initializeWasm() must be awaited first!");
26514 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone_ptr(arg);
26515 return nativeResponseValue;
26517 // struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
26519 export function CommitmentTransaction_clone(orig: number): number {
26520 if(!isWasmInitialized) {
26521 throw new Error("initializeWasm() must be awaited first!");
26523 const nativeResponseValue = wasm.TS_CommitmentTransaction_clone(orig);
26524 return nativeResponseValue;
26526 // struct LDKCVec_u8Z CommitmentTransaction_write(const struct LDKCommitmentTransaction *NONNULL_PTR obj);
26528 export function CommitmentTransaction_write(obj: number): number {
26529 if(!isWasmInitialized) {
26530 throw new Error("initializeWasm() must be awaited first!");
26532 const nativeResponseValue = wasm.TS_CommitmentTransaction_write(obj);
26533 return nativeResponseValue;
26535 // struct LDKCResult_CommitmentTransactionDecodeErrorZ CommitmentTransaction_read(struct LDKu8slice ser);
26537 export function CommitmentTransaction_read(ser: number): number {
26538 if(!isWasmInitialized) {
26539 throw new Error("initializeWasm() must be awaited first!");
26541 const nativeResponseValue = wasm.TS_CommitmentTransaction_read(ser);
26542 return nativeResponseValue;
26544 // MUST_USE_RES uint64_t CommitmentTransaction_commitment_number(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26546 export function CommitmentTransaction_commitment_number(this_arg: number): bigint {
26547 if(!isWasmInitialized) {
26548 throw new Error("initializeWasm() must be awaited first!");
26550 const nativeResponseValue = wasm.TS_CommitmentTransaction_commitment_number(this_arg);
26551 return nativeResponseValue;
26553 // MUST_USE_RES uint64_t CommitmentTransaction_to_broadcaster_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26555 export function CommitmentTransaction_to_broadcaster_value_sat(this_arg: number): bigint {
26556 if(!isWasmInitialized) {
26557 throw new Error("initializeWasm() must be awaited first!");
26559 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_broadcaster_value_sat(this_arg);
26560 return nativeResponseValue;
26562 // MUST_USE_RES uint64_t CommitmentTransaction_to_countersignatory_value_sat(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26564 export function CommitmentTransaction_to_countersignatory_value_sat(this_arg: number): bigint {
26565 if(!isWasmInitialized) {
26566 throw new Error("initializeWasm() must be awaited first!");
26568 const nativeResponseValue = wasm.TS_CommitmentTransaction_to_countersignatory_value_sat(this_arg);
26569 return nativeResponseValue;
26571 // MUST_USE_RES uint32_t CommitmentTransaction_feerate_per_kw(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26573 export function CommitmentTransaction_feerate_per_kw(this_arg: number): number {
26574 if(!isWasmInitialized) {
26575 throw new Error("initializeWasm() must be awaited first!");
26577 const nativeResponseValue = wasm.TS_CommitmentTransaction_feerate_per_kw(this_arg);
26578 return nativeResponseValue;
26580 // MUST_USE_RES struct LDKTrustedCommitmentTransaction CommitmentTransaction_trust(const struct LDKCommitmentTransaction *NONNULL_PTR this_arg);
26582 export function CommitmentTransaction_trust(this_arg: number): number {
26583 if(!isWasmInitialized) {
26584 throw new Error("initializeWasm() must be awaited first!");
26586 const nativeResponseValue = wasm.TS_CommitmentTransaction_trust(this_arg);
26587 return nativeResponseValue;
26589 // 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);
26591 export function CommitmentTransaction_verify(this_arg: number, channel_parameters: number, broadcaster_keys: number, countersignatory_keys: number): number {
26592 if(!isWasmInitialized) {
26593 throw new Error("initializeWasm() must be awaited first!");
26595 const nativeResponseValue = wasm.TS_CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
26596 return nativeResponseValue;
26598 // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
26600 export function TrustedCommitmentTransaction_free(this_obj: number): void {
26601 if(!isWasmInitialized) {
26602 throw new Error("initializeWasm() must be awaited first!");
26604 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_free(this_obj);
26605 // debug statements here
26607 // MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26609 export function TrustedCommitmentTransaction_txid(this_arg: number): number {
26610 if(!isWasmInitialized) {
26611 throw new Error("initializeWasm() must be awaited first!");
26613 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_txid(this_arg);
26614 return nativeResponseValue;
26616 // MUST_USE_RES struct LDKBuiltCommitmentTransaction TrustedCommitmentTransaction_built_transaction(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26618 export function TrustedCommitmentTransaction_built_transaction(this_arg: number): number {
26619 if(!isWasmInitialized) {
26620 throw new Error("initializeWasm() must be awaited first!");
26622 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_built_transaction(this_arg);
26623 return nativeResponseValue;
26625 // MUST_USE_RES struct LDKTxCreationKeys TrustedCommitmentTransaction_keys(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26627 export function TrustedCommitmentTransaction_keys(this_arg: number): number {
26628 if(!isWasmInitialized) {
26629 throw new Error("initializeWasm() must be awaited first!");
26631 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_keys(this_arg);
26632 return nativeResponseValue;
26634 // MUST_USE_RES bool TrustedCommitmentTransaction_opt_anchors(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
26636 export function TrustedCommitmentTransaction_opt_anchors(this_arg: number): boolean {
26637 if(!isWasmInitialized) {
26638 throw new Error("initializeWasm() must be awaited first!");
26640 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_opt_anchors(this_arg);
26641 return nativeResponseValue;
26643 // 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);
26645 export function TrustedCommitmentTransaction_get_htlc_sigs(this_arg: number, htlc_base_key: number, channel_parameters: number): number {
26646 if(!isWasmInitialized) {
26647 throw new Error("initializeWasm() must be awaited first!");
26649 const nativeResponseValue = wasm.TS_TrustedCommitmentTransaction_get_htlc_sigs(this_arg, htlc_base_key, channel_parameters);
26650 return nativeResponseValue;
26652 // uint64_t get_commitment_transaction_number_obscure_factor(struct LDKPublicKey broadcaster_payment_basepoint, struct LDKPublicKey countersignatory_payment_basepoint, bool outbound_from_broadcaster);
26654 export function get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint: number, countersignatory_payment_basepoint: number, outbound_from_broadcaster: boolean): bigint {
26655 if(!isWasmInitialized) {
26656 throw new Error("initializeWasm() must be awaited first!");
26658 const nativeResponseValue = wasm.TS_get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint, countersignatory_payment_basepoint, outbound_from_broadcaster);
26659 return nativeResponseValue;
26661 // bool InitFeatures_eq(const struct LDKInitFeatures *NONNULL_PTR a, const struct LDKInitFeatures *NONNULL_PTR b);
26663 export function InitFeatures_eq(a: number, b: number): boolean {
26664 if(!isWasmInitialized) {
26665 throw new Error("initializeWasm() must be awaited first!");
26667 const nativeResponseValue = wasm.TS_InitFeatures_eq(a, b);
26668 return nativeResponseValue;
26670 // bool NodeFeatures_eq(const struct LDKNodeFeatures *NONNULL_PTR a, const struct LDKNodeFeatures *NONNULL_PTR b);
26672 export function NodeFeatures_eq(a: number, b: number): boolean {
26673 if(!isWasmInitialized) {
26674 throw new Error("initializeWasm() must be awaited first!");
26676 const nativeResponseValue = wasm.TS_NodeFeatures_eq(a, b);
26677 return nativeResponseValue;
26679 // bool ChannelFeatures_eq(const struct LDKChannelFeatures *NONNULL_PTR a, const struct LDKChannelFeatures *NONNULL_PTR b);
26681 export function ChannelFeatures_eq(a: number, b: number): boolean {
26682 if(!isWasmInitialized) {
26683 throw new Error("initializeWasm() must be awaited first!");
26685 const nativeResponseValue = wasm.TS_ChannelFeatures_eq(a, b);
26686 return nativeResponseValue;
26688 // bool InvoiceFeatures_eq(const struct LDKInvoiceFeatures *NONNULL_PTR a, const struct LDKInvoiceFeatures *NONNULL_PTR b);
26690 export function InvoiceFeatures_eq(a: number, b: number): boolean {
26691 if(!isWasmInitialized) {
26692 throw new Error("initializeWasm() must be awaited first!");
26694 const nativeResponseValue = wasm.TS_InvoiceFeatures_eq(a, b);
26695 return nativeResponseValue;
26697 // bool ChannelTypeFeatures_eq(const struct LDKChannelTypeFeatures *NONNULL_PTR a, const struct LDKChannelTypeFeatures *NONNULL_PTR b);
26699 export function ChannelTypeFeatures_eq(a: number, b: number): boolean {
26700 if(!isWasmInitialized) {
26701 throw new Error("initializeWasm() must be awaited first!");
26703 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_eq(a, b);
26704 return nativeResponseValue;
26706 // uintptr_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg);
26708 export function InitFeatures_clone_ptr(arg: number): number {
26709 if(!isWasmInitialized) {
26710 throw new Error("initializeWasm() must be awaited first!");
26712 const nativeResponseValue = wasm.TS_InitFeatures_clone_ptr(arg);
26713 return nativeResponseValue;
26715 // struct LDKInitFeatures InitFeatures_clone(const struct LDKInitFeatures *NONNULL_PTR orig);
26717 export function InitFeatures_clone(orig: number): number {
26718 if(!isWasmInitialized) {
26719 throw new Error("initializeWasm() must be awaited first!");
26721 const nativeResponseValue = wasm.TS_InitFeatures_clone(orig);
26722 return nativeResponseValue;
26724 // uintptr_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg);
26726 export function NodeFeatures_clone_ptr(arg: number): number {
26727 if(!isWasmInitialized) {
26728 throw new Error("initializeWasm() must be awaited first!");
26730 const nativeResponseValue = wasm.TS_NodeFeatures_clone_ptr(arg);
26731 return nativeResponseValue;
26733 // struct LDKNodeFeatures NodeFeatures_clone(const struct LDKNodeFeatures *NONNULL_PTR orig);
26735 export function NodeFeatures_clone(orig: number): number {
26736 if(!isWasmInitialized) {
26737 throw new Error("initializeWasm() must be awaited first!");
26739 const nativeResponseValue = wasm.TS_NodeFeatures_clone(orig);
26740 return nativeResponseValue;
26742 // uintptr_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg);
26744 export function ChannelFeatures_clone_ptr(arg: number): number {
26745 if(!isWasmInitialized) {
26746 throw new Error("initializeWasm() must be awaited first!");
26748 const nativeResponseValue = wasm.TS_ChannelFeatures_clone_ptr(arg);
26749 return nativeResponseValue;
26751 // struct LDKChannelFeatures ChannelFeatures_clone(const struct LDKChannelFeatures *NONNULL_PTR orig);
26753 export function ChannelFeatures_clone(orig: number): number {
26754 if(!isWasmInitialized) {
26755 throw new Error("initializeWasm() must be awaited first!");
26757 const nativeResponseValue = wasm.TS_ChannelFeatures_clone(orig);
26758 return nativeResponseValue;
26760 // uintptr_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg);
26762 export function InvoiceFeatures_clone_ptr(arg: number): number {
26763 if(!isWasmInitialized) {
26764 throw new Error("initializeWasm() must be awaited first!");
26766 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone_ptr(arg);
26767 return nativeResponseValue;
26769 // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
26771 export function InvoiceFeatures_clone(orig: number): number {
26772 if(!isWasmInitialized) {
26773 throw new Error("initializeWasm() must be awaited first!");
26775 const nativeResponseValue = wasm.TS_InvoiceFeatures_clone(orig);
26776 return nativeResponseValue;
26778 // uintptr_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg);
26780 export function ChannelTypeFeatures_clone_ptr(arg: number): number {
26781 if(!isWasmInitialized) {
26782 throw new Error("initializeWasm() must be awaited first!");
26784 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone_ptr(arg);
26785 return nativeResponseValue;
26787 // struct LDKChannelTypeFeatures ChannelTypeFeatures_clone(const struct LDKChannelTypeFeatures *NONNULL_PTR orig);
26789 export function ChannelTypeFeatures_clone(orig: number): number {
26790 if(!isWasmInitialized) {
26791 throw new Error("initializeWasm() must be awaited first!");
26793 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_clone(orig);
26794 return nativeResponseValue;
26796 // void InitFeatures_free(struct LDKInitFeatures this_obj);
26798 export function InitFeatures_free(this_obj: number): void {
26799 if(!isWasmInitialized) {
26800 throw new Error("initializeWasm() must be awaited first!");
26802 const nativeResponseValue = wasm.TS_InitFeatures_free(this_obj);
26803 // debug statements here
26805 // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
26807 export function NodeFeatures_free(this_obj: number): void {
26808 if(!isWasmInitialized) {
26809 throw new Error("initializeWasm() must be awaited first!");
26811 const nativeResponseValue = wasm.TS_NodeFeatures_free(this_obj);
26812 // debug statements here
26814 // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
26816 export function ChannelFeatures_free(this_obj: number): void {
26817 if(!isWasmInitialized) {
26818 throw new Error("initializeWasm() must be awaited first!");
26820 const nativeResponseValue = wasm.TS_ChannelFeatures_free(this_obj);
26821 // debug statements here
26823 // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
26825 export function InvoiceFeatures_free(this_obj: number): void {
26826 if(!isWasmInitialized) {
26827 throw new Error("initializeWasm() must be awaited first!");
26829 const nativeResponseValue = wasm.TS_InvoiceFeatures_free(this_obj);
26830 // debug statements here
26832 // void ChannelTypeFeatures_free(struct LDKChannelTypeFeatures this_obj);
26834 export function ChannelTypeFeatures_free(this_obj: number): void {
26835 if(!isWasmInitialized) {
26836 throw new Error("initializeWasm() must be awaited first!");
26838 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_free(this_obj);
26839 // debug statements here
26841 // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
26843 export function InitFeatures_empty(): number {
26844 if(!isWasmInitialized) {
26845 throw new Error("initializeWasm() must be awaited first!");
26847 const nativeResponseValue = wasm.TS_InitFeatures_empty();
26848 return nativeResponseValue;
26850 // MUST_USE_RES struct LDKInitFeatures InitFeatures_known(void);
26852 export function InitFeatures_known(): number {
26853 if(!isWasmInitialized) {
26854 throw new Error("initializeWasm() must be awaited first!");
26856 const nativeResponseValue = wasm.TS_InitFeatures_known();
26857 return nativeResponseValue;
26859 // MUST_USE_RES bool InitFeatures_requires_unknown_bits(const struct LDKInitFeatures *NONNULL_PTR this_arg);
26861 export function InitFeatures_requires_unknown_bits(this_arg: number): boolean {
26862 if(!isWasmInitialized) {
26863 throw new Error("initializeWasm() must be awaited first!");
26865 const nativeResponseValue = wasm.TS_InitFeatures_requires_unknown_bits(this_arg);
26866 return nativeResponseValue;
26868 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_empty(void);
26870 export function NodeFeatures_empty(): number {
26871 if(!isWasmInitialized) {
26872 throw new Error("initializeWasm() must be awaited first!");
26874 const nativeResponseValue = wasm.TS_NodeFeatures_empty();
26875 return nativeResponseValue;
26877 // MUST_USE_RES struct LDKNodeFeatures NodeFeatures_known(void);
26879 export function NodeFeatures_known(): number {
26880 if(!isWasmInitialized) {
26881 throw new Error("initializeWasm() must be awaited first!");
26883 const nativeResponseValue = wasm.TS_NodeFeatures_known();
26884 return nativeResponseValue;
26886 // MUST_USE_RES bool NodeFeatures_requires_unknown_bits(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
26888 export function NodeFeatures_requires_unknown_bits(this_arg: number): boolean {
26889 if(!isWasmInitialized) {
26890 throw new Error("initializeWasm() must be awaited first!");
26892 const nativeResponseValue = wasm.TS_NodeFeatures_requires_unknown_bits(this_arg);
26893 return nativeResponseValue;
26895 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_empty(void);
26897 export function ChannelFeatures_empty(): number {
26898 if(!isWasmInitialized) {
26899 throw new Error("initializeWasm() must be awaited first!");
26901 const nativeResponseValue = wasm.TS_ChannelFeatures_empty();
26902 return nativeResponseValue;
26904 // MUST_USE_RES struct LDKChannelFeatures ChannelFeatures_known(void);
26906 export function ChannelFeatures_known(): number {
26907 if(!isWasmInitialized) {
26908 throw new Error("initializeWasm() must be awaited first!");
26910 const nativeResponseValue = wasm.TS_ChannelFeatures_known();
26911 return nativeResponseValue;
26913 // MUST_USE_RES bool ChannelFeatures_requires_unknown_bits(const struct LDKChannelFeatures *NONNULL_PTR this_arg);
26915 export function ChannelFeatures_requires_unknown_bits(this_arg: number): boolean {
26916 if(!isWasmInitialized) {
26917 throw new Error("initializeWasm() must be awaited first!");
26919 const nativeResponseValue = wasm.TS_ChannelFeatures_requires_unknown_bits(this_arg);
26920 return nativeResponseValue;
26922 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
26924 export function InvoiceFeatures_empty(): number {
26925 if(!isWasmInitialized) {
26926 throw new Error("initializeWasm() must be awaited first!");
26928 const nativeResponseValue = wasm.TS_InvoiceFeatures_empty();
26929 return nativeResponseValue;
26931 // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
26933 export function InvoiceFeatures_known(): number {
26934 if(!isWasmInitialized) {
26935 throw new Error("initializeWasm() must be awaited first!");
26937 const nativeResponseValue = wasm.TS_InvoiceFeatures_known();
26938 return nativeResponseValue;
26940 // MUST_USE_RES bool InvoiceFeatures_requires_unknown_bits(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
26942 export function InvoiceFeatures_requires_unknown_bits(this_arg: number): boolean {
26943 if(!isWasmInitialized) {
26944 throw new Error("initializeWasm() must be awaited first!");
26946 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_unknown_bits(this_arg);
26947 return nativeResponseValue;
26949 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_empty(void);
26951 export function ChannelTypeFeatures_empty(): number {
26952 if(!isWasmInitialized) {
26953 throw new Error("initializeWasm() must be awaited first!");
26955 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_empty();
26956 return nativeResponseValue;
26958 // MUST_USE_RES struct LDKChannelTypeFeatures ChannelTypeFeatures_known(void);
26960 export function ChannelTypeFeatures_known(): number {
26961 if(!isWasmInitialized) {
26962 throw new Error("initializeWasm() must be awaited first!");
26964 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_known();
26965 return nativeResponseValue;
26967 // MUST_USE_RES bool ChannelTypeFeatures_requires_unknown_bits(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
26969 export function ChannelTypeFeatures_requires_unknown_bits(this_arg: number): boolean {
26970 if(!isWasmInitialized) {
26971 throw new Error("initializeWasm() must be awaited first!");
26973 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_unknown_bits(this_arg);
26974 return nativeResponseValue;
26976 // struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
26978 export function InitFeatures_write(obj: number): number {
26979 if(!isWasmInitialized) {
26980 throw new Error("initializeWasm() must be awaited first!");
26982 const nativeResponseValue = wasm.TS_InitFeatures_write(obj);
26983 return nativeResponseValue;
26985 // struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
26987 export function InitFeatures_read(ser: number): number {
26988 if(!isWasmInitialized) {
26989 throw new Error("initializeWasm() must be awaited first!");
26991 const nativeResponseValue = wasm.TS_InitFeatures_read(ser);
26992 return nativeResponseValue;
26994 // struct LDKCVec_u8Z ChannelFeatures_write(const struct LDKChannelFeatures *NONNULL_PTR obj);
26996 export function ChannelFeatures_write(obj: number): number {
26997 if(!isWasmInitialized) {
26998 throw new Error("initializeWasm() must be awaited first!");
27000 const nativeResponseValue = wasm.TS_ChannelFeatures_write(obj);
27001 return nativeResponseValue;
27003 // struct LDKCResult_ChannelFeaturesDecodeErrorZ ChannelFeatures_read(struct LDKu8slice ser);
27005 export function ChannelFeatures_read(ser: number): number {
27006 if(!isWasmInitialized) {
27007 throw new Error("initializeWasm() must be awaited first!");
27009 const nativeResponseValue = wasm.TS_ChannelFeatures_read(ser);
27010 return nativeResponseValue;
27012 // struct LDKCVec_u8Z NodeFeatures_write(const struct LDKNodeFeatures *NONNULL_PTR obj);
27014 export function NodeFeatures_write(obj: number): number {
27015 if(!isWasmInitialized) {
27016 throw new Error("initializeWasm() must be awaited first!");
27018 const nativeResponseValue = wasm.TS_NodeFeatures_write(obj);
27019 return nativeResponseValue;
27021 // struct LDKCResult_NodeFeaturesDecodeErrorZ NodeFeatures_read(struct LDKu8slice ser);
27023 export function NodeFeatures_read(ser: number): number {
27024 if(!isWasmInitialized) {
27025 throw new Error("initializeWasm() must be awaited first!");
27027 const nativeResponseValue = wasm.TS_NodeFeatures_read(ser);
27028 return nativeResponseValue;
27030 // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
27032 export function InvoiceFeatures_write(obj: number): number {
27033 if(!isWasmInitialized) {
27034 throw new Error("initializeWasm() must be awaited first!");
27036 const nativeResponseValue = wasm.TS_InvoiceFeatures_write(obj);
27037 return nativeResponseValue;
27039 // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
27041 export function InvoiceFeatures_read(ser: number): number {
27042 if(!isWasmInitialized) {
27043 throw new Error("initializeWasm() must be awaited first!");
27045 const nativeResponseValue = wasm.TS_InvoiceFeatures_read(ser);
27046 return nativeResponseValue;
27048 // struct LDKCVec_u8Z ChannelTypeFeatures_write(const struct LDKChannelTypeFeatures *NONNULL_PTR obj);
27050 export function ChannelTypeFeatures_write(obj: number): number {
27051 if(!isWasmInitialized) {
27052 throw new Error("initializeWasm() must be awaited first!");
27054 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_write(obj);
27055 return nativeResponseValue;
27057 // struct LDKCResult_ChannelTypeFeaturesDecodeErrorZ ChannelTypeFeatures_read(struct LDKu8slice ser);
27059 export function ChannelTypeFeatures_read(ser: number): number {
27060 if(!isWasmInitialized) {
27061 throw new Error("initializeWasm() must be awaited first!");
27063 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_read(ser);
27064 return nativeResponseValue;
27066 // void InitFeatures_set_data_loss_protect_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27068 export function InitFeatures_set_data_loss_protect_optional(this_arg: number): void {
27069 if(!isWasmInitialized) {
27070 throw new Error("initializeWasm() must be awaited first!");
27072 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_optional(this_arg);
27073 // debug statements here
27075 // void InitFeatures_set_data_loss_protect_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27077 export function InitFeatures_set_data_loss_protect_required(this_arg: number): void {
27078 if(!isWasmInitialized) {
27079 throw new Error("initializeWasm() must be awaited first!");
27081 const nativeResponseValue = wasm.TS_InitFeatures_set_data_loss_protect_required(this_arg);
27082 // debug statements here
27084 // MUST_USE_RES bool InitFeatures_supports_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27086 export function InitFeatures_supports_data_loss_protect(this_arg: number): boolean {
27087 if(!isWasmInitialized) {
27088 throw new Error("initializeWasm() must be awaited first!");
27090 const nativeResponseValue = wasm.TS_InitFeatures_supports_data_loss_protect(this_arg);
27091 return nativeResponseValue;
27093 // void NodeFeatures_set_data_loss_protect_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27095 export function NodeFeatures_set_data_loss_protect_optional(this_arg: number): void {
27096 if(!isWasmInitialized) {
27097 throw new Error("initializeWasm() must be awaited first!");
27099 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_optional(this_arg);
27100 // debug statements here
27102 // void NodeFeatures_set_data_loss_protect_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27104 export function NodeFeatures_set_data_loss_protect_required(this_arg: number): void {
27105 if(!isWasmInitialized) {
27106 throw new Error("initializeWasm() must be awaited first!");
27108 const nativeResponseValue = wasm.TS_NodeFeatures_set_data_loss_protect_required(this_arg);
27109 // debug statements here
27111 // MUST_USE_RES bool NodeFeatures_supports_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27113 export function NodeFeatures_supports_data_loss_protect(this_arg: number): boolean {
27114 if(!isWasmInitialized) {
27115 throw new Error("initializeWasm() must be awaited first!");
27117 const nativeResponseValue = wasm.TS_NodeFeatures_supports_data_loss_protect(this_arg);
27118 return nativeResponseValue;
27120 // MUST_USE_RES bool InitFeatures_requires_data_loss_protect(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27122 export function InitFeatures_requires_data_loss_protect(this_arg: number): boolean {
27123 if(!isWasmInitialized) {
27124 throw new Error("initializeWasm() must be awaited first!");
27126 const nativeResponseValue = wasm.TS_InitFeatures_requires_data_loss_protect(this_arg);
27127 return nativeResponseValue;
27129 // MUST_USE_RES bool NodeFeatures_requires_data_loss_protect(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27131 export function NodeFeatures_requires_data_loss_protect(this_arg: number): boolean {
27132 if(!isWasmInitialized) {
27133 throw new Error("initializeWasm() must be awaited first!");
27135 const nativeResponseValue = wasm.TS_NodeFeatures_requires_data_loss_protect(this_arg);
27136 return nativeResponseValue;
27138 // void InitFeatures_set_initial_routing_sync_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27140 export function InitFeatures_set_initial_routing_sync_optional(this_arg: number): void {
27141 if(!isWasmInitialized) {
27142 throw new Error("initializeWasm() must be awaited first!");
27144 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_optional(this_arg);
27145 // debug statements here
27147 // void InitFeatures_set_initial_routing_sync_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27149 export function InitFeatures_set_initial_routing_sync_required(this_arg: number): void {
27150 if(!isWasmInitialized) {
27151 throw new Error("initializeWasm() must be awaited first!");
27153 const nativeResponseValue = wasm.TS_InitFeatures_set_initial_routing_sync_required(this_arg);
27154 // debug statements here
27156 // MUST_USE_RES bool InitFeatures_initial_routing_sync(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27158 export function InitFeatures_initial_routing_sync(this_arg: number): boolean {
27159 if(!isWasmInitialized) {
27160 throw new Error("initializeWasm() must be awaited first!");
27162 const nativeResponseValue = wasm.TS_InitFeatures_initial_routing_sync(this_arg);
27163 return nativeResponseValue;
27165 // void InitFeatures_set_upfront_shutdown_script_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27167 export function InitFeatures_set_upfront_shutdown_script_optional(this_arg: number): void {
27168 if(!isWasmInitialized) {
27169 throw new Error("initializeWasm() must be awaited first!");
27171 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_optional(this_arg);
27172 // debug statements here
27174 // void InitFeatures_set_upfront_shutdown_script_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27176 export function InitFeatures_set_upfront_shutdown_script_required(this_arg: number): void {
27177 if(!isWasmInitialized) {
27178 throw new Error("initializeWasm() must be awaited first!");
27180 const nativeResponseValue = wasm.TS_InitFeatures_set_upfront_shutdown_script_required(this_arg);
27181 // debug statements here
27183 // MUST_USE_RES bool InitFeatures_supports_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27185 export function InitFeatures_supports_upfront_shutdown_script(this_arg: number): boolean {
27186 if(!isWasmInitialized) {
27187 throw new Error("initializeWasm() must be awaited first!");
27189 const nativeResponseValue = wasm.TS_InitFeatures_supports_upfront_shutdown_script(this_arg);
27190 return nativeResponseValue;
27192 // void NodeFeatures_set_upfront_shutdown_script_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27194 export function NodeFeatures_set_upfront_shutdown_script_optional(this_arg: number): void {
27195 if(!isWasmInitialized) {
27196 throw new Error("initializeWasm() must be awaited first!");
27198 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_optional(this_arg);
27199 // debug statements here
27201 // void NodeFeatures_set_upfront_shutdown_script_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27203 export function NodeFeatures_set_upfront_shutdown_script_required(this_arg: number): void {
27204 if(!isWasmInitialized) {
27205 throw new Error("initializeWasm() must be awaited first!");
27207 const nativeResponseValue = wasm.TS_NodeFeatures_set_upfront_shutdown_script_required(this_arg);
27208 // debug statements here
27210 // MUST_USE_RES bool NodeFeatures_supports_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27212 export function NodeFeatures_supports_upfront_shutdown_script(this_arg: number): boolean {
27213 if(!isWasmInitialized) {
27214 throw new Error("initializeWasm() must be awaited first!");
27216 const nativeResponseValue = wasm.TS_NodeFeatures_supports_upfront_shutdown_script(this_arg);
27217 return nativeResponseValue;
27219 // MUST_USE_RES bool InitFeatures_requires_upfront_shutdown_script(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27221 export function InitFeatures_requires_upfront_shutdown_script(this_arg: number): boolean {
27222 if(!isWasmInitialized) {
27223 throw new Error("initializeWasm() must be awaited first!");
27225 const nativeResponseValue = wasm.TS_InitFeatures_requires_upfront_shutdown_script(this_arg);
27226 return nativeResponseValue;
27228 // MUST_USE_RES bool NodeFeatures_requires_upfront_shutdown_script(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27230 export function NodeFeatures_requires_upfront_shutdown_script(this_arg: number): boolean {
27231 if(!isWasmInitialized) {
27232 throw new Error("initializeWasm() must be awaited first!");
27234 const nativeResponseValue = wasm.TS_NodeFeatures_requires_upfront_shutdown_script(this_arg);
27235 return nativeResponseValue;
27237 // void InitFeatures_set_gossip_queries_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27239 export function InitFeatures_set_gossip_queries_optional(this_arg: number): void {
27240 if(!isWasmInitialized) {
27241 throw new Error("initializeWasm() must be awaited first!");
27243 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_optional(this_arg);
27244 // debug statements here
27246 // void InitFeatures_set_gossip_queries_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27248 export function InitFeatures_set_gossip_queries_required(this_arg: number): void {
27249 if(!isWasmInitialized) {
27250 throw new Error("initializeWasm() must be awaited first!");
27252 const nativeResponseValue = wasm.TS_InitFeatures_set_gossip_queries_required(this_arg);
27253 // debug statements here
27255 // MUST_USE_RES bool InitFeatures_supports_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27257 export function InitFeatures_supports_gossip_queries(this_arg: number): boolean {
27258 if(!isWasmInitialized) {
27259 throw new Error("initializeWasm() must be awaited first!");
27261 const nativeResponseValue = wasm.TS_InitFeatures_supports_gossip_queries(this_arg);
27262 return nativeResponseValue;
27264 // void NodeFeatures_set_gossip_queries_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27266 export function NodeFeatures_set_gossip_queries_optional(this_arg: number): void {
27267 if(!isWasmInitialized) {
27268 throw new Error("initializeWasm() must be awaited first!");
27270 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_optional(this_arg);
27271 // debug statements here
27273 // void NodeFeatures_set_gossip_queries_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27275 export function NodeFeatures_set_gossip_queries_required(this_arg: number): void {
27276 if(!isWasmInitialized) {
27277 throw new Error("initializeWasm() must be awaited first!");
27279 const nativeResponseValue = wasm.TS_NodeFeatures_set_gossip_queries_required(this_arg);
27280 // debug statements here
27282 // MUST_USE_RES bool NodeFeatures_supports_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27284 export function NodeFeatures_supports_gossip_queries(this_arg: number): boolean {
27285 if(!isWasmInitialized) {
27286 throw new Error("initializeWasm() must be awaited first!");
27288 const nativeResponseValue = wasm.TS_NodeFeatures_supports_gossip_queries(this_arg);
27289 return nativeResponseValue;
27291 // MUST_USE_RES bool InitFeatures_requires_gossip_queries(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27293 export function InitFeatures_requires_gossip_queries(this_arg: number): boolean {
27294 if(!isWasmInitialized) {
27295 throw new Error("initializeWasm() must be awaited first!");
27297 const nativeResponseValue = wasm.TS_InitFeatures_requires_gossip_queries(this_arg);
27298 return nativeResponseValue;
27300 // MUST_USE_RES bool NodeFeatures_requires_gossip_queries(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27302 export function NodeFeatures_requires_gossip_queries(this_arg: number): boolean {
27303 if(!isWasmInitialized) {
27304 throw new Error("initializeWasm() must be awaited first!");
27306 const nativeResponseValue = wasm.TS_NodeFeatures_requires_gossip_queries(this_arg);
27307 return nativeResponseValue;
27309 // void InitFeatures_set_variable_length_onion_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27311 export function InitFeatures_set_variable_length_onion_optional(this_arg: number): void {
27312 if(!isWasmInitialized) {
27313 throw new Error("initializeWasm() must be awaited first!");
27315 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_optional(this_arg);
27316 // debug statements here
27318 // void InitFeatures_set_variable_length_onion_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27320 export function InitFeatures_set_variable_length_onion_required(this_arg: number): void {
27321 if(!isWasmInitialized) {
27322 throw new Error("initializeWasm() must be awaited first!");
27324 const nativeResponseValue = wasm.TS_InitFeatures_set_variable_length_onion_required(this_arg);
27325 // debug statements here
27327 // MUST_USE_RES bool InitFeatures_supports_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27329 export function InitFeatures_supports_variable_length_onion(this_arg: number): boolean {
27330 if(!isWasmInitialized) {
27331 throw new Error("initializeWasm() must be awaited first!");
27333 const nativeResponseValue = wasm.TS_InitFeatures_supports_variable_length_onion(this_arg);
27334 return nativeResponseValue;
27336 // void NodeFeatures_set_variable_length_onion_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27338 export function NodeFeatures_set_variable_length_onion_optional(this_arg: number): void {
27339 if(!isWasmInitialized) {
27340 throw new Error("initializeWasm() must be awaited first!");
27342 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_optional(this_arg);
27343 // debug statements here
27345 // void NodeFeatures_set_variable_length_onion_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27347 export function NodeFeatures_set_variable_length_onion_required(this_arg: number): void {
27348 if(!isWasmInitialized) {
27349 throw new Error("initializeWasm() must be awaited first!");
27351 const nativeResponseValue = wasm.TS_NodeFeatures_set_variable_length_onion_required(this_arg);
27352 // debug statements here
27354 // MUST_USE_RES bool NodeFeatures_supports_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27356 export function NodeFeatures_supports_variable_length_onion(this_arg: number): boolean {
27357 if(!isWasmInitialized) {
27358 throw new Error("initializeWasm() must be awaited first!");
27360 const nativeResponseValue = wasm.TS_NodeFeatures_supports_variable_length_onion(this_arg);
27361 return nativeResponseValue;
27363 // void InvoiceFeatures_set_variable_length_onion_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27365 export function InvoiceFeatures_set_variable_length_onion_optional(this_arg: number): void {
27366 if(!isWasmInitialized) {
27367 throw new Error("initializeWasm() must be awaited first!");
27369 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_optional(this_arg);
27370 // debug statements here
27372 // void InvoiceFeatures_set_variable_length_onion_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27374 export function InvoiceFeatures_set_variable_length_onion_required(this_arg: number): void {
27375 if(!isWasmInitialized) {
27376 throw new Error("initializeWasm() must be awaited first!");
27378 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_variable_length_onion_required(this_arg);
27379 // debug statements here
27381 // MUST_USE_RES bool InvoiceFeatures_supports_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27383 export function InvoiceFeatures_supports_variable_length_onion(this_arg: number): boolean {
27384 if(!isWasmInitialized) {
27385 throw new Error("initializeWasm() must be awaited first!");
27387 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_variable_length_onion(this_arg);
27388 return nativeResponseValue;
27390 // MUST_USE_RES bool InitFeatures_requires_variable_length_onion(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27392 export function InitFeatures_requires_variable_length_onion(this_arg: number): boolean {
27393 if(!isWasmInitialized) {
27394 throw new Error("initializeWasm() must be awaited first!");
27396 const nativeResponseValue = wasm.TS_InitFeatures_requires_variable_length_onion(this_arg);
27397 return nativeResponseValue;
27399 // MUST_USE_RES bool NodeFeatures_requires_variable_length_onion(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27401 export function NodeFeatures_requires_variable_length_onion(this_arg: number): boolean {
27402 if(!isWasmInitialized) {
27403 throw new Error("initializeWasm() must be awaited first!");
27405 const nativeResponseValue = wasm.TS_NodeFeatures_requires_variable_length_onion(this_arg);
27406 return nativeResponseValue;
27408 // MUST_USE_RES bool InvoiceFeatures_requires_variable_length_onion(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27410 export function InvoiceFeatures_requires_variable_length_onion(this_arg: number): boolean {
27411 if(!isWasmInitialized) {
27412 throw new Error("initializeWasm() must be awaited first!");
27414 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_variable_length_onion(this_arg);
27415 return nativeResponseValue;
27417 // void InitFeatures_set_static_remote_key_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27419 export function InitFeatures_set_static_remote_key_optional(this_arg: number): void {
27420 if(!isWasmInitialized) {
27421 throw new Error("initializeWasm() must be awaited first!");
27423 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_optional(this_arg);
27424 // debug statements here
27426 // void InitFeatures_set_static_remote_key_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27428 export function InitFeatures_set_static_remote_key_required(this_arg: number): void {
27429 if(!isWasmInitialized) {
27430 throw new Error("initializeWasm() must be awaited first!");
27432 const nativeResponseValue = wasm.TS_InitFeatures_set_static_remote_key_required(this_arg);
27433 // debug statements here
27435 // MUST_USE_RES bool InitFeatures_supports_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27437 export function InitFeatures_supports_static_remote_key(this_arg: number): boolean {
27438 if(!isWasmInitialized) {
27439 throw new Error("initializeWasm() must be awaited first!");
27441 const nativeResponseValue = wasm.TS_InitFeatures_supports_static_remote_key(this_arg);
27442 return nativeResponseValue;
27444 // void NodeFeatures_set_static_remote_key_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27446 export function NodeFeatures_set_static_remote_key_optional(this_arg: number): void {
27447 if(!isWasmInitialized) {
27448 throw new Error("initializeWasm() must be awaited first!");
27450 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_optional(this_arg);
27451 // debug statements here
27453 // void NodeFeatures_set_static_remote_key_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27455 export function NodeFeatures_set_static_remote_key_required(this_arg: number): void {
27456 if(!isWasmInitialized) {
27457 throw new Error("initializeWasm() must be awaited first!");
27459 const nativeResponseValue = wasm.TS_NodeFeatures_set_static_remote_key_required(this_arg);
27460 // debug statements here
27462 // MUST_USE_RES bool NodeFeatures_supports_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27464 export function NodeFeatures_supports_static_remote_key(this_arg: number): boolean {
27465 if(!isWasmInitialized) {
27466 throw new Error("initializeWasm() must be awaited first!");
27468 const nativeResponseValue = wasm.TS_NodeFeatures_supports_static_remote_key(this_arg);
27469 return nativeResponseValue;
27471 // void ChannelTypeFeatures_set_static_remote_key_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27473 export function ChannelTypeFeatures_set_static_remote_key_optional(this_arg: number): void {
27474 if(!isWasmInitialized) {
27475 throw new Error("initializeWasm() must be awaited first!");
27477 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_optional(this_arg);
27478 // debug statements here
27480 // void ChannelTypeFeatures_set_static_remote_key_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27482 export function ChannelTypeFeatures_set_static_remote_key_required(this_arg: number): void {
27483 if(!isWasmInitialized) {
27484 throw new Error("initializeWasm() must be awaited first!");
27486 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_static_remote_key_required(this_arg);
27487 // debug statements here
27489 // MUST_USE_RES bool ChannelTypeFeatures_supports_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27491 export function ChannelTypeFeatures_supports_static_remote_key(this_arg: number): boolean {
27492 if(!isWasmInitialized) {
27493 throw new Error("initializeWasm() must be awaited first!");
27495 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_static_remote_key(this_arg);
27496 return nativeResponseValue;
27498 // MUST_USE_RES bool InitFeatures_requires_static_remote_key(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27500 export function InitFeatures_requires_static_remote_key(this_arg: number): boolean {
27501 if(!isWasmInitialized) {
27502 throw new Error("initializeWasm() must be awaited first!");
27504 const nativeResponseValue = wasm.TS_InitFeatures_requires_static_remote_key(this_arg);
27505 return nativeResponseValue;
27507 // MUST_USE_RES bool NodeFeatures_requires_static_remote_key(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27509 export function NodeFeatures_requires_static_remote_key(this_arg: number): boolean {
27510 if(!isWasmInitialized) {
27511 throw new Error("initializeWasm() must be awaited first!");
27513 const nativeResponseValue = wasm.TS_NodeFeatures_requires_static_remote_key(this_arg);
27514 return nativeResponseValue;
27516 // MUST_USE_RES bool ChannelTypeFeatures_requires_static_remote_key(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
27518 export function ChannelTypeFeatures_requires_static_remote_key(this_arg: number): boolean {
27519 if(!isWasmInitialized) {
27520 throw new Error("initializeWasm() must be awaited first!");
27522 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_static_remote_key(this_arg);
27523 return nativeResponseValue;
27525 // void InitFeatures_set_payment_secret_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27527 export function InitFeatures_set_payment_secret_optional(this_arg: number): void {
27528 if(!isWasmInitialized) {
27529 throw new Error("initializeWasm() must be awaited first!");
27531 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_optional(this_arg);
27532 // debug statements here
27534 // void InitFeatures_set_payment_secret_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27536 export function InitFeatures_set_payment_secret_required(this_arg: number): void {
27537 if(!isWasmInitialized) {
27538 throw new Error("initializeWasm() must be awaited first!");
27540 const nativeResponseValue = wasm.TS_InitFeatures_set_payment_secret_required(this_arg);
27541 // debug statements here
27543 // MUST_USE_RES bool InitFeatures_supports_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27545 export function InitFeatures_supports_payment_secret(this_arg: number): boolean {
27546 if(!isWasmInitialized) {
27547 throw new Error("initializeWasm() must be awaited first!");
27549 const nativeResponseValue = wasm.TS_InitFeatures_supports_payment_secret(this_arg);
27550 return nativeResponseValue;
27552 // void NodeFeatures_set_payment_secret_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27554 export function NodeFeatures_set_payment_secret_optional(this_arg: number): void {
27555 if(!isWasmInitialized) {
27556 throw new Error("initializeWasm() must be awaited first!");
27558 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_optional(this_arg);
27559 // debug statements here
27561 // void NodeFeatures_set_payment_secret_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27563 export function NodeFeatures_set_payment_secret_required(this_arg: number): void {
27564 if(!isWasmInitialized) {
27565 throw new Error("initializeWasm() must be awaited first!");
27567 const nativeResponseValue = wasm.TS_NodeFeatures_set_payment_secret_required(this_arg);
27568 // debug statements here
27570 // MUST_USE_RES bool NodeFeatures_supports_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27572 export function NodeFeatures_supports_payment_secret(this_arg: number): boolean {
27573 if(!isWasmInitialized) {
27574 throw new Error("initializeWasm() must be awaited first!");
27576 const nativeResponseValue = wasm.TS_NodeFeatures_supports_payment_secret(this_arg);
27577 return nativeResponseValue;
27579 // void InvoiceFeatures_set_payment_secret_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27581 export function InvoiceFeatures_set_payment_secret_optional(this_arg: number): void {
27582 if(!isWasmInitialized) {
27583 throw new Error("initializeWasm() must be awaited first!");
27585 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_optional(this_arg);
27586 // debug statements here
27588 // void InvoiceFeatures_set_payment_secret_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27590 export function InvoiceFeatures_set_payment_secret_required(this_arg: number): void {
27591 if(!isWasmInitialized) {
27592 throw new Error("initializeWasm() must be awaited first!");
27594 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_payment_secret_required(this_arg);
27595 // debug statements here
27597 // MUST_USE_RES bool InvoiceFeatures_supports_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27599 export function InvoiceFeatures_supports_payment_secret(this_arg: number): boolean {
27600 if(!isWasmInitialized) {
27601 throw new Error("initializeWasm() must be awaited first!");
27603 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_payment_secret(this_arg);
27604 return nativeResponseValue;
27606 // MUST_USE_RES bool InitFeatures_requires_payment_secret(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27608 export function InitFeatures_requires_payment_secret(this_arg: number): boolean {
27609 if(!isWasmInitialized) {
27610 throw new Error("initializeWasm() must be awaited first!");
27612 const nativeResponseValue = wasm.TS_InitFeatures_requires_payment_secret(this_arg);
27613 return nativeResponseValue;
27615 // MUST_USE_RES bool NodeFeatures_requires_payment_secret(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27617 export function NodeFeatures_requires_payment_secret(this_arg: number): boolean {
27618 if(!isWasmInitialized) {
27619 throw new Error("initializeWasm() must be awaited first!");
27621 const nativeResponseValue = wasm.TS_NodeFeatures_requires_payment_secret(this_arg);
27622 return nativeResponseValue;
27624 // MUST_USE_RES bool InvoiceFeatures_requires_payment_secret(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27626 export function InvoiceFeatures_requires_payment_secret(this_arg: number): boolean {
27627 if(!isWasmInitialized) {
27628 throw new Error("initializeWasm() must be awaited first!");
27630 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_payment_secret(this_arg);
27631 return nativeResponseValue;
27633 // void InitFeatures_set_basic_mpp_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27635 export function InitFeatures_set_basic_mpp_optional(this_arg: number): void {
27636 if(!isWasmInitialized) {
27637 throw new Error("initializeWasm() must be awaited first!");
27639 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_optional(this_arg);
27640 // debug statements here
27642 // void InitFeatures_set_basic_mpp_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27644 export function InitFeatures_set_basic_mpp_required(this_arg: number): void {
27645 if(!isWasmInitialized) {
27646 throw new Error("initializeWasm() must be awaited first!");
27648 const nativeResponseValue = wasm.TS_InitFeatures_set_basic_mpp_required(this_arg);
27649 // debug statements here
27651 // MUST_USE_RES bool InitFeatures_supports_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27653 export function InitFeatures_supports_basic_mpp(this_arg: number): boolean {
27654 if(!isWasmInitialized) {
27655 throw new Error("initializeWasm() must be awaited first!");
27657 const nativeResponseValue = wasm.TS_InitFeatures_supports_basic_mpp(this_arg);
27658 return nativeResponseValue;
27660 // void NodeFeatures_set_basic_mpp_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27662 export function NodeFeatures_set_basic_mpp_optional(this_arg: number): void {
27663 if(!isWasmInitialized) {
27664 throw new Error("initializeWasm() must be awaited first!");
27666 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_optional(this_arg);
27667 // debug statements here
27669 // void NodeFeatures_set_basic_mpp_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27671 export function NodeFeatures_set_basic_mpp_required(this_arg: number): void {
27672 if(!isWasmInitialized) {
27673 throw new Error("initializeWasm() must be awaited first!");
27675 const nativeResponseValue = wasm.TS_NodeFeatures_set_basic_mpp_required(this_arg);
27676 // debug statements here
27678 // MUST_USE_RES bool NodeFeatures_supports_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27680 export function NodeFeatures_supports_basic_mpp(this_arg: number): boolean {
27681 if(!isWasmInitialized) {
27682 throw new Error("initializeWasm() must be awaited first!");
27684 const nativeResponseValue = wasm.TS_NodeFeatures_supports_basic_mpp(this_arg);
27685 return nativeResponseValue;
27687 // void InvoiceFeatures_set_basic_mpp_optional(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27689 export function InvoiceFeatures_set_basic_mpp_optional(this_arg: number): void {
27690 if(!isWasmInitialized) {
27691 throw new Error("initializeWasm() must be awaited first!");
27693 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_optional(this_arg);
27694 // debug statements here
27696 // void InvoiceFeatures_set_basic_mpp_required(struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27698 export function InvoiceFeatures_set_basic_mpp_required(this_arg: number): void {
27699 if(!isWasmInitialized) {
27700 throw new Error("initializeWasm() must be awaited first!");
27702 const nativeResponseValue = wasm.TS_InvoiceFeatures_set_basic_mpp_required(this_arg);
27703 // debug statements here
27705 // MUST_USE_RES bool InvoiceFeatures_supports_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27707 export function InvoiceFeatures_supports_basic_mpp(this_arg: number): boolean {
27708 if(!isWasmInitialized) {
27709 throw new Error("initializeWasm() must be awaited first!");
27711 const nativeResponseValue = wasm.TS_InvoiceFeatures_supports_basic_mpp(this_arg);
27712 return nativeResponseValue;
27714 // MUST_USE_RES bool InitFeatures_requires_basic_mpp(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27716 export function InitFeatures_requires_basic_mpp(this_arg: number): boolean {
27717 if(!isWasmInitialized) {
27718 throw new Error("initializeWasm() must be awaited first!");
27720 const nativeResponseValue = wasm.TS_InitFeatures_requires_basic_mpp(this_arg);
27721 return nativeResponseValue;
27723 // MUST_USE_RES bool NodeFeatures_requires_basic_mpp(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27725 export function NodeFeatures_requires_basic_mpp(this_arg: number): boolean {
27726 if(!isWasmInitialized) {
27727 throw new Error("initializeWasm() must be awaited first!");
27729 const nativeResponseValue = wasm.TS_NodeFeatures_requires_basic_mpp(this_arg);
27730 return nativeResponseValue;
27732 // MUST_USE_RES bool InvoiceFeatures_requires_basic_mpp(const struct LDKInvoiceFeatures *NONNULL_PTR this_arg);
27734 export function InvoiceFeatures_requires_basic_mpp(this_arg: number): boolean {
27735 if(!isWasmInitialized) {
27736 throw new Error("initializeWasm() must be awaited first!");
27738 const nativeResponseValue = wasm.TS_InvoiceFeatures_requires_basic_mpp(this_arg);
27739 return nativeResponseValue;
27741 // void InitFeatures_set_wumbo_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27743 export function InitFeatures_set_wumbo_optional(this_arg: number): void {
27744 if(!isWasmInitialized) {
27745 throw new Error("initializeWasm() must be awaited first!");
27747 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_optional(this_arg);
27748 // debug statements here
27750 // void InitFeatures_set_wumbo_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27752 export function InitFeatures_set_wumbo_required(this_arg: number): void {
27753 if(!isWasmInitialized) {
27754 throw new Error("initializeWasm() must be awaited first!");
27756 const nativeResponseValue = wasm.TS_InitFeatures_set_wumbo_required(this_arg);
27757 // debug statements here
27759 // MUST_USE_RES bool InitFeatures_supports_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27761 export function InitFeatures_supports_wumbo(this_arg: number): boolean {
27762 if(!isWasmInitialized) {
27763 throw new Error("initializeWasm() must be awaited first!");
27765 const nativeResponseValue = wasm.TS_InitFeatures_supports_wumbo(this_arg);
27766 return nativeResponseValue;
27768 // void NodeFeatures_set_wumbo_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27770 export function NodeFeatures_set_wumbo_optional(this_arg: number): void {
27771 if(!isWasmInitialized) {
27772 throw new Error("initializeWasm() must be awaited first!");
27774 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_optional(this_arg);
27775 // debug statements here
27777 // void NodeFeatures_set_wumbo_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27779 export function NodeFeatures_set_wumbo_required(this_arg: number): void {
27780 if(!isWasmInitialized) {
27781 throw new Error("initializeWasm() must be awaited first!");
27783 const nativeResponseValue = wasm.TS_NodeFeatures_set_wumbo_required(this_arg);
27784 // debug statements here
27786 // MUST_USE_RES bool NodeFeatures_supports_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27788 export function NodeFeatures_supports_wumbo(this_arg: number): boolean {
27789 if(!isWasmInitialized) {
27790 throw new Error("initializeWasm() must be awaited first!");
27792 const nativeResponseValue = wasm.TS_NodeFeatures_supports_wumbo(this_arg);
27793 return nativeResponseValue;
27795 // MUST_USE_RES bool InitFeatures_requires_wumbo(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27797 export function InitFeatures_requires_wumbo(this_arg: number): boolean {
27798 if(!isWasmInitialized) {
27799 throw new Error("initializeWasm() must be awaited first!");
27801 const nativeResponseValue = wasm.TS_InitFeatures_requires_wumbo(this_arg);
27802 return nativeResponseValue;
27804 // MUST_USE_RES bool NodeFeatures_requires_wumbo(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27806 export function NodeFeatures_requires_wumbo(this_arg: number): boolean {
27807 if(!isWasmInitialized) {
27808 throw new Error("initializeWasm() must be awaited first!");
27810 const nativeResponseValue = wasm.TS_NodeFeatures_requires_wumbo(this_arg);
27811 return nativeResponseValue;
27813 // void InitFeatures_set_shutdown_any_segwit_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27815 export function InitFeatures_set_shutdown_any_segwit_optional(this_arg: number): void {
27816 if(!isWasmInitialized) {
27817 throw new Error("initializeWasm() must be awaited first!");
27819 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_optional(this_arg);
27820 // debug statements here
27822 // void InitFeatures_set_shutdown_any_segwit_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27824 export function InitFeatures_set_shutdown_any_segwit_required(this_arg: number): void {
27825 if(!isWasmInitialized) {
27826 throw new Error("initializeWasm() must be awaited first!");
27828 const nativeResponseValue = wasm.TS_InitFeatures_set_shutdown_any_segwit_required(this_arg);
27829 // debug statements here
27831 // MUST_USE_RES bool InitFeatures_supports_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27833 export function InitFeatures_supports_shutdown_anysegwit(this_arg: number): boolean {
27834 if(!isWasmInitialized) {
27835 throw new Error("initializeWasm() must be awaited first!");
27837 const nativeResponseValue = wasm.TS_InitFeatures_supports_shutdown_anysegwit(this_arg);
27838 return nativeResponseValue;
27840 // void NodeFeatures_set_shutdown_any_segwit_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27842 export function NodeFeatures_set_shutdown_any_segwit_optional(this_arg: number): void {
27843 if(!isWasmInitialized) {
27844 throw new Error("initializeWasm() must be awaited first!");
27846 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_optional(this_arg);
27847 // debug statements here
27849 // void NodeFeatures_set_shutdown_any_segwit_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27851 export function NodeFeatures_set_shutdown_any_segwit_required(this_arg: number): void {
27852 if(!isWasmInitialized) {
27853 throw new Error("initializeWasm() must be awaited first!");
27855 const nativeResponseValue = wasm.TS_NodeFeatures_set_shutdown_any_segwit_required(this_arg);
27856 // debug statements here
27858 // MUST_USE_RES bool NodeFeatures_supports_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27860 export function NodeFeatures_supports_shutdown_anysegwit(this_arg: number): boolean {
27861 if(!isWasmInitialized) {
27862 throw new Error("initializeWasm() must be awaited first!");
27864 const nativeResponseValue = wasm.TS_NodeFeatures_supports_shutdown_anysegwit(this_arg);
27865 return nativeResponseValue;
27867 // MUST_USE_RES bool InitFeatures_requires_shutdown_anysegwit(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27869 export function InitFeatures_requires_shutdown_anysegwit(this_arg: number): boolean {
27870 if(!isWasmInitialized) {
27871 throw new Error("initializeWasm() must be awaited first!");
27873 const nativeResponseValue = wasm.TS_InitFeatures_requires_shutdown_anysegwit(this_arg);
27874 return nativeResponseValue;
27876 // MUST_USE_RES bool NodeFeatures_requires_shutdown_anysegwit(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27878 export function NodeFeatures_requires_shutdown_anysegwit(this_arg: number): boolean {
27879 if(!isWasmInitialized) {
27880 throw new Error("initializeWasm() must be awaited first!");
27882 const nativeResponseValue = wasm.TS_NodeFeatures_requires_shutdown_anysegwit(this_arg);
27883 return nativeResponseValue;
27885 // void InitFeatures_set_channel_type_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27887 export function InitFeatures_set_channel_type_optional(this_arg: number): void {
27888 if(!isWasmInitialized) {
27889 throw new Error("initializeWasm() must be awaited first!");
27891 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_optional(this_arg);
27892 // debug statements here
27894 // void InitFeatures_set_channel_type_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27896 export function InitFeatures_set_channel_type_required(this_arg: number): void {
27897 if(!isWasmInitialized) {
27898 throw new Error("initializeWasm() must be awaited first!");
27900 const nativeResponseValue = wasm.TS_InitFeatures_set_channel_type_required(this_arg);
27901 // debug statements here
27903 // MUST_USE_RES bool InitFeatures_supports_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27905 export function InitFeatures_supports_channel_type(this_arg: number): boolean {
27906 if(!isWasmInitialized) {
27907 throw new Error("initializeWasm() must be awaited first!");
27909 const nativeResponseValue = wasm.TS_InitFeatures_supports_channel_type(this_arg);
27910 return nativeResponseValue;
27912 // void NodeFeatures_set_channel_type_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27914 export function NodeFeatures_set_channel_type_optional(this_arg: number): void {
27915 if(!isWasmInitialized) {
27916 throw new Error("initializeWasm() must be awaited first!");
27918 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_optional(this_arg);
27919 // debug statements here
27921 // void NodeFeatures_set_channel_type_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27923 export function NodeFeatures_set_channel_type_required(this_arg: number): void {
27924 if(!isWasmInitialized) {
27925 throw new Error("initializeWasm() must be awaited first!");
27927 const nativeResponseValue = wasm.TS_NodeFeatures_set_channel_type_required(this_arg);
27928 // debug statements here
27930 // MUST_USE_RES bool NodeFeatures_supports_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27932 export function NodeFeatures_supports_channel_type(this_arg: number): boolean {
27933 if(!isWasmInitialized) {
27934 throw new Error("initializeWasm() must be awaited first!");
27936 const nativeResponseValue = wasm.TS_NodeFeatures_supports_channel_type(this_arg);
27937 return nativeResponseValue;
27939 // MUST_USE_RES bool InitFeatures_requires_channel_type(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27941 export function InitFeatures_requires_channel_type(this_arg: number): boolean {
27942 if(!isWasmInitialized) {
27943 throw new Error("initializeWasm() must be awaited first!");
27945 const nativeResponseValue = wasm.TS_InitFeatures_requires_channel_type(this_arg);
27946 return nativeResponseValue;
27948 // MUST_USE_RES bool NodeFeatures_requires_channel_type(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
27950 export function NodeFeatures_requires_channel_type(this_arg: number): boolean {
27951 if(!isWasmInitialized) {
27952 throw new Error("initializeWasm() must be awaited first!");
27954 const nativeResponseValue = wasm.TS_NodeFeatures_requires_channel_type(this_arg);
27955 return nativeResponseValue;
27957 // void InitFeatures_set_scid_privacy_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
27959 export function InitFeatures_set_scid_privacy_optional(this_arg: number): void {
27960 if(!isWasmInitialized) {
27961 throw new Error("initializeWasm() must be awaited first!");
27963 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_optional(this_arg);
27964 // debug statements here
27966 // void InitFeatures_set_scid_privacy_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
27968 export function InitFeatures_set_scid_privacy_required(this_arg: number): void {
27969 if(!isWasmInitialized) {
27970 throw new Error("initializeWasm() must be awaited first!");
27972 const nativeResponseValue = wasm.TS_InitFeatures_set_scid_privacy_required(this_arg);
27973 // debug statements here
27975 // MUST_USE_RES bool InitFeatures_supports_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
27977 export function InitFeatures_supports_scid_privacy(this_arg: number): boolean {
27978 if(!isWasmInitialized) {
27979 throw new Error("initializeWasm() must be awaited first!");
27981 const nativeResponseValue = wasm.TS_InitFeatures_supports_scid_privacy(this_arg);
27982 return nativeResponseValue;
27984 // void NodeFeatures_set_scid_privacy_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27986 export function NodeFeatures_set_scid_privacy_optional(this_arg: number): void {
27987 if(!isWasmInitialized) {
27988 throw new Error("initializeWasm() must be awaited first!");
27990 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_optional(this_arg);
27991 // debug statements here
27993 // void NodeFeatures_set_scid_privacy_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
27995 export function NodeFeatures_set_scid_privacy_required(this_arg: number): void {
27996 if(!isWasmInitialized) {
27997 throw new Error("initializeWasm() must be awaited first!");
27999 const nativeResponseValue = wasm.TS_NodeFeatures_set_scid_privacy_required(this_arg);
28000 // debug statements here
28002 // MUST_USE_RES bool NodeFeatures_supports_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28004 export function NodeFeatures_supports_scid_privacy(this_arg: number): boolean {
28005 if(!isWasmInitialized) {
28006 throw new Error("initializeWasm() must be awaited first!");
28008 const nativeResponseValue = wasm.TS_NodeFeatures_supports_scid_privacy(this_arg);
28009 return nativeResponseValue;
28011 // void ChannelTypeFeatures_set_scid_privacy_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28013 export function ChannelTypeFeatures_set_scid_privacy_optional(this_arg: number): void {
28014 if(!isWasmInitialized) {
28015 throw new Error("initializeWasm() must be awaited first!");
28017 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_optional(this_arg);
28018 // debug statements here
28020 // void ChannelTypeFeatures_set_scid_privacy_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28022 export function ChannelTypeFeatures_set_scid_privacy_required(this_arg: number): void {
28023 if(!isWasmInitialized) {
28024 throw new Error("initializeWasm() must be awaited first!");
28026 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_scid_privacy_required(this_arg);
28027 // debug statements here
28029 // MUST_USE_RES bool ChannelTypeFeatures_supports_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28031 export function ChannelTypeFeatures_supports_scid_privacy(this_arg: number): boolean {
28032 if(!isWasmInitialized) {
28033 throw new Error("initializeWasm() must be awaited first!");
28035 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_scid_privacy(this_arg);
28036 return nativeResponseValue;
28038 // MUST_USE_RES bool InitFeatures_requires_scid_privacy(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28040 export function InitFeatures_requires_scid_privacy(this_arg: number): boolean {
28041 if(!isWasmInitialized) {
28042 throw new Error("initializeWasm() must be awaited first!");
28044 const nativeResponseValue = wasm.TS_InitFeatures_requires_scid_privacy(this_arg);
28045 return nativeResponseValue;
28047 // MUST_USE_RES bool NodeFeatures_requires_scid_privacy(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28049 export function NodeFeatures_requires_scid_privacy(this_arg: number): boolean {
28050 if(!isWasmInitialized) {
28051 throw new Error("initializeWasm() must be awaited first!");
28053 const nativeResponseValue = wasm.TS_NodeFeatures_requires_scid_privacy(this_arg);
28054 return nativeResponseValue;
28056 // MUST_USE_RES bool ChannelTypeFeatures_requires_scid_privacy(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28058 export function ChannelTypeFeatures_requires_scid_privacy(this_arg: number): boolean {
28059 if(!isWasmInitialized) {
28060 throw new Error("initializeWasm() must be awaited first!");
28062 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_scid_privacy(this_arg);
28063 return nativeResponseValue;
28065 // void InitFeatures_set_zero_conf_optional(struct LDKInitFeatures *NONNULL_PTR this_arg);
28067 export function InitFeatures_set_zero_conf_optional(this_arg: number): void {
28068 if(!isWasmInitialized) {
28069 throw new Error("initializeWasm() must be awaited first!");
28071 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_optional(this_arg);
28072 // debug statements here
28074 // void InitFeatures_set_zero_conf_required(struct LDKInitFeatures *NONNULL_PTR this_arg);
28076 export function InitFeatures_set_zero_conf_required(this_arg: number): void {
28077 if(!isWasmInitialized) {
28078 throw new Error("initializeWasm() must be awaited first!");
28080 const nativeResponseValue = wasm.TS_InitFeatures_set_zero_conf_required(this_arg);
28081 // debug statements here
28083 // MUST_USE_RES bool InitFeatures_supports_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28085 export function InitFeatures_supports_zero_conf(this_arg: number): boolean {
28086 if(!isWasmInitialized) {
28087 throw new Error("initializeWasm() must be awaited first!");
28089 const nativeResponseValue = wasm.TS_InitFeatures_supports_zero_conf(this_arg);
28090 return nativeResponseValue;
28092 // void NodeFeatures_set_zero_conf_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28094 export function NodeFeatures_set_zero_conf_optional(this_arg: number): void {
28095 if(!isWasmInitialized) {
28096 throw new Error("initializeWasm() must be awaited first!");
28098 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_optional(this_arg);
28099 // debug statements here
28101 // void NodeFeatures_set_zero_conf_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28103 export function NodeFeatures_set_zero_conf_required(this_arg: number): void {
28104 if(!isWasmInitialized) {
28105 throw new Error("initializeWasm() must be awaited first!");
28107 const nativeResponseValue = wasm.TS_NodeFeatures_set_zero_conf_required(this_arg);
28108 // debug statements here
28110 // MUST_USE_RES bool NodeFeatures_supports_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28112 export function NodeFeatures_supports_zero_conf(this_arg: number): boolean {
28113 if(!isWasmInitialized) {
28114 throw new Error("initializeWasm() must be awaited first!");
28116 const nativeResponseValue = wasm.TS_NodeFeatures_supports_zero_conf(this_arg);
28117 return nativeResponseValue;
28119 // void ChannelTypeFeatures_set_zero_conf_optional(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28121 export function ChannelTypeFeatures_set_zero_conf_optional(this_arg: number): void {
28122 if(!isWasmInitialized) {
28123 throw new Error("initializeWasm() must be awaited first!");
28125 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_optional(this_arg);
28126 // debug statements here
28128 // void ChannelTypeFeatures_set_zero_conf_required(struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28130 export function ChannelTypeFeatures_set_zero_conf_required(this_arg: number): void {
28131 if(!isWasmInitialized) {
28132 throw new Error("initializeWasm() must be awaited first!");
28134 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_set_zero_conf_required(this_arg);
28135 // debug statements here
28137 // MUST_USE_RES bool ChannelTypeFeatures_supports_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28139 export function ChannelTypeFeatures_supports_zero_conf(this_arg: number): boolean {
28140 if(!isWasmInitialized) {
28141 throw new Error("initializeWasm() must be awaited first!");
28143 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_supports_zero_conf(this_arg);
28144 return nativeResponseValue;
28146 // MUST_USE_RES bool InitFeatures_requires_zero_conf(const struct LDKInitFeatures *NONNULL_PTR this_arg);
28148 export function InitFeatures_requires_zero_conf(this_arg: number): boolean {
28149 if(!isWasmInitialized) {
28150 throw new Error("initializeWasm() must be awaited first!");
28152 const nativeResponseValue = wasm.TS_InitFeatures_requires_zero_conf(this_arg);
28153 return nativeResponseValue;
28155 // MUST_USE_RES bool NodeFeatures_requires_zero_conf(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28157 export function NodeFeatures_requires_zero_conf(this_arg: number): boolean {
28158 if(!isWasmInitialized) {
28159 throw new Error("initializeWasm() must be awaited first!");
28161 const nativeResponseValue = wasm.TS_NodeFeatures_requires_zero_conf(this_arg);
28162 return nativeResponseValue;
28164 // MUST_USE_RES bool ChannelTypeFeatures_requires_zero_conf(const struct LDKChannelTypeFeatures *NONNULL_PTR this_arg);
28166 export function ChannelTypeFeatures_requires_zero_conf(this_arg: number): boolean {
28167 if(!isWasmInitialized) {
28168 throw new Error("initializeWasm() must be awaited first!");
28170 const nativeResponseValue = wasm.TS_ChannelTypeFeatures_requires_zero_conf(this_arg);
28171 return nativeResponseValue;
28173 // void NodeFeatures_set_keysend_optional(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28175 export function NodeFeatures_set_keysend_optional(this_arg: number): void {
28176 if(!isWasmInitialized) {
28177 throw new Error("initializeWasm() must be awaited first!");
28179 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_optional(this_arg);
28180 // debug statements here
28182 // void NodeFeatures_set_keysend_required(struct LDKNodeFeatures *NONNULL_PTR this_arg);
28184 export function NodeFeatures_set_keysend_required(this_arg: number): void {
28185 if(!isWasmInitialized) {
28186 throw new Error("initializeWasm() must be awaited first!");
28188 const nativeResponseValue = wasm.TS_NodeFeatures_set_keysend_required(this_arg);
28189 // debug statements here
28191 // MUST_USE_RES bool NodeFeatures_supports_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28193 export function NodeFeatures_supports_keysend(this_arg: number): boolean {
28194 if(!isWasmInitialized) {
28195 throw new Error("initializeWasm() must be awaited first!");
28197 const nativeResponseValue = wasm.TS_NodeFeatures_supports_keysend(this_arg);
28198 return nativeResponseValue;
28200 // MUST_USE_RES bool NodeFeatures_requires_keysend(const struct LDKNodeFeatures *NONNULL_PTR this_arg);
28202 export function NodeFeatures_requires_keysend(this_arg: number): boolean {
28203 if(!isWasmInitialized) {
28204 throw new Error("initializeWasm() must be awaited first!");
28206 const nativeResponseValue = wasm.TS_NodeFeatures_requires_keysend(this_arg);
28207 return nativeResponseValue;
28209 // void ShutdownScript_free(struct LDKShutdownScript this_obj);
28211 export function ShutdownScript_free(this_obj: number): void {
28212 if(!isWasmInitialized) {
28213 throw new Error("initializeWasm() must be awaited first!");
28215 const nativeResponseValue = wasm.TS_ShutdownScript_free(this_obj);
28216 // debug statements here
28218 // uintptr_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg);
28220 export function ShutdownScript_clone_ptr(arg: number): number {
28221 if(!isWasmInitialized) {
28222 throw new Error("initializeWasm() must be awaited first!");
28224 const nativeResponseValue = wasm.TS_ShutdownScript_clone_ptr(arg);
28225 return nativeResponseValue;
28227 // struct LDKShutdownScript ShutdownScript_clone(const struct LDKShutdownScript *NONNULL_PTR orig);
28229 export function ShutdownScript_clone(orig: number): number {
28230 if(!isWasmInitialized) {
28231 throw new Error("initializeWasm() must be awaited first!");
28233 const nativeResponseValue = wasm.TS_ShutdownScript_clone(orig);
28234 return nativeResponseValue;
28236 // void InvalidShutdownScript_free(struct LDKInvalidShutdownScript this_obj);
28238 export function InvalidShutdownScript_free(this_obj: number): void {
28239 if(!isWasmInitialized) {
28240 throw new Error("initializeWasm() must be awaited first!");
28242 const nativeResponseValue = wasm.TS_InvalidShutdownScript_free(this_obj);
28243 // debug statements here
28245 // struct LDKu8slice InvalidShutdownScript_get_script(const struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr);
28247 export function InvalidShutdownScript_get_script(this_ptr: number): number {
28248 if(!isWasmInitialized) {
28249 throw new Error("initializeWasm() must be awaited first!");
28251 const nativeResponseValue = wasm.TS_InvalidShutdownScript_get_script(this_ptr);
28252 return nativeResponseValue;
28254 // void InvalidShutdownScript_set_script(struct LDKInvalidShutdownScript *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
28256 export function InvalidShutdownScript_set_script(this_ptr: number, val: number): void {
28257 if(!isWasmInitialized) {
28258 throw new Error("initializeWasm() must be awaited first!");
28260 const nativeResponseValue = wasm.TS_InvalidShutdownScript_set_script(this_ptr, val);
28261 // debug statements here
28263 // MUST_USE_RES struct LDKInvalidShutdownScript InvalidShutdownScript_new(struct LDKCVec_u8Z script_arg);
28265 export function InvalidShutdownScript_new(script_arg: number): number {
28266 if(!isWasmInitialized) {
28267 throw new Error("initializeWasm() must be awaited first!");
28269 const nativeResponseValue = wasm.TS_InvalidShutdownScript_new(script_arg);
28270 return nativeResponseValue;
28272 // uintptr_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg);
28274 export function InvalidShutdownScript_clone_ptr(arg: number): number {
28275 if(!isWasmInitialized) {
28276 throw new Error("initializeWasm() must be awaited first!");
28278 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone_ptr(arg);
28279 return nativeResponseValue;
28281 // struct LDKInvalidShutdownScript InvalidShutdownScript_clone(const struct LDKInvalidShutdownScript *NONNULL_PTR orig);
28283 export function InvalidShutdownScript_clone(orig: number): number {
28284 if(!isWasmInitialized) {
28285 throw new Error("initializeWasm() must be awaited first!");
28287 const nativeResponseValue = wasm.TS_InvalidShutdownScript_clone(orig);
28288 return nativeResponseValue;
28290 // struct LDKCVec_u8Z ShutdownScript_write(const struct LDKShutdownScript *NONNULL_PTR obj);
28292 export function ShutdownScript_write(obj: number): number {
28293 if(!isWasmInitialized) {
28294 throw new Error("initializeWasm() must be awaited first!");
28296 const nativeResponseValue = wasm.TS_ShutdownScript_write(obj);
28297 return nativeResponseValue;
28299 // struct LDKCResult_ShutdownScriptDecodeErrorZ ShutdownScript_read(struct LDKu8slice ser);
28301 export function ShutdownScript_read(ser: number): number {
28302 if(!isWasmInitialized) {
28303 throw new Error("initializeWasm() must be awaited first!");
28305 const nativeResponseValue = wasm.TS_ShutdownScript_read(ser);
28306 return nativeResponseValue;
28308 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wpkh(const uint8_t (*pubkey_hash)[20]);
28310 export function ShutdownScript_new_p2wpkh(pubkey_hash: number): number {
28311 if(!isWasmInitialized) {
28312 throw new Error("initializeWasm() must be awaited first!");
28314 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wpkh(pubkey_hash);
28315 return nativeResponseValue;
28317 // MUST_USE_RES struct LDKShutdownScript ShutdownScript_new_p2wsh(const uint8_t (*script_hash)[32]);
28319 export function ShutdownScript_new_p2wsh(script_hash: number): number {
28320 if(!isWasmInitialized) {
28321 throw new Error("initializeWasm() must be awaited first!");
28323 const nativeResponseValue = wasm.TS_ShutdownScript_new_p2wsh(script_hash);
28324 return nativeResponseValue;
28326 // MUST_USE_RES struct LDKCResult_ShutdownScriptInvalidShutdownScriptZ ShutdownScript_new_witness_program(struct LDKWitnessVersion version, struct LDKu8slice program);
28328 export function ShutdownScript_new_witness_program(version: number, program: number): number {
28329 if(!isWasmInitialized) {
28330 throw new Error("initializeWasm() must be awaited first!");
28332 const nativeResponseValue = wasm.TS_ShutdownScript_new_witness_program(version, program);
28333 return nativeResponseValue;
28335 // MUST_USE_RES struct LDKCVec_u8Z ShutdownScript_into_inner(struct LDKShutdownScript this_arg);
28337 export function ShutdownScript_into_inner(this_arg: number): number {
28338 if(!isWasmInitialized) {
28339 throw new Error("initializeWasm() must be awaited first!");
28341 const nativeResponseValue = wasm.TS_ShutdownScript_into_inner(this_arg);
28342 return nativeResponseValue;
28344 // MUST_USE_RES struct LDKPublicKey ShutdownScript_as_legacy_pubkey(const struct LDKShutdownScript *NONNULL_PTR this_arg);
28346 export function ShutdownScript_as_legacy_pubkey(this_arg: number): number {
28347 if(!isWasmInitialized) {
28348 throw new Error("initializeWasm() must be awaited first!");
28350 const nativeResponseValue = wasm.TS_ShutdownScript_as_legacy_pubkey(this_arg);
28351 return nativeResponseValue;
28353 // MUST_USE_RES bool ShutdownScript_is_compatible(const struct LDKShutdownScript *NONNULL_PTR this_arg, const struct LDKInitFeatures *NONNULL_PTR features);
28355 export function ShutdownScript_is_compatible(this_arg: number, features: number): boolean {
28356 if(!isWasmInitialized) {
28357 throw new Error("initializeWasm() must be awaited first!");
28359 const nativeResponseValue = wasm.TS_ShutdownScript_is_compatible(this_arg, features);
28360 return nativeResponseValue;
28362 // void CustomMessageReader_free(struct LDKCustomMessageReader this_ptr);
28364 export function CustomMessageReader_free(this_ptr: number): void {
28365 if(!isWasmInitialized) {
28366 throw new Error("initializeWasm() must be awaited first!");
28368 const nativeResponseValue = wasm.TS_CustomMessageReader_free(this_ptr);
28369 // debug statements here
28371 // uintptr_t Type_clone_ptr(LDKType *NONNULL_PTR arg);
28373 export function Type_clone_ptr(arg: number): number {
28374 if(!isWasmInitialized) {
28375 throw new Error("initializeWasm() must be awaited first!");
28377 const nativeResponseValue = wasm.TS_Type_clone_ptr(arg);
28378 return nativeResponseValue;
28380 // struct LDKType Type_clone(const struct LDKType *NONNULL_PTR orig);
28382 export function Type_clone(orig: number): number {
28383 if(!isWasmInitialized) {
28384 throw new Error("initializeWasm() must be awaited first!");
28386 const nativeResponseValue = wasm.TS_Type_clone(orig);
28387 return nativeResponseValue;
28389 // void Type_free(struct LDKType this_ptr);
28391 export function Type_free(this_ptr: number): void {
28392 if(!isWasmInitialized) {
28393 throw new Error("initializeWasm() must be awaited first!");
28395 const nativeResponseValue = wasm.TS_Type_free(this_ptr);
28396 // debug statements here
28398 // void NodeId_free(struct LDKNodeId this_obj);
28400 export function NodeId_free(this_obj: number): void {
28401 if(!isWasmInitialized) {
28402 throw new Error("initializeWasm() must be awaited first!");
28404 const nativeResponseValue = wasm.TS_NodeId_free(this_obj);
28405 // debug statements here
28407 // uintptr_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg);
28409 export function NodeId_clone_ptr(arg: number): number {
28410 if(!isWasmInitialized) {
28411 throw new Error("initializeWasm() must be awaited first!");
28413 const nativeResponseValue = wasm.TS_NodeId_clone_ptr(arg);
28414 return nativeResponseValue;
28416 // struct LDKNodeId NodeId_clone(const struct LDKNodeId *NONNULL_PTR orig);
28418 export function NodeId_clone(orig: number): number {
28419 if(!isWasmInitialized) {
28420 throw new Error("initializeWasm() must be awaited first!");
28422 const nativeResponseValue = wasm.TS_NodeId_clone(orig);
28423 return nativeResponseValue;
28425 // MUST_USE_RES struct LDKNodeId NodeId_from_pubkey(struct LDKPublicKey pubkey);
28427 export function NodeId_from_pubkey(pubkey: number): number {
28428 if(!isWasmInitialized) {
28429 throw new Error("initializeWasm() must be awaited first!");
28431 const nativeResponseValue = wasm.TS_NodeId_from_pubkey(pubkey);
28432 return nativeResponseValue;
28434 // MUST_USE_RES struct LDKu8slice NodeId_as_slice(const struct LDKNodeId *NONNULL_PTR this_arg);
28436 export function NodeId_as_slice(this_arg: number): number {
28437 if(!isWasmInitialized) {
28438 throw new Error("initializeWasm() must be awaited first!");
28440 const nativeResponseValue = wasm.TS_NodeId_as_slice(this_arg);
28441 return nativeResponseValue;
28443 // uint64_t NodeId_hash(const struct LDKNodeId *NONNULL_PTR o);
28445 export function NodeId_hash(o: number): bigint {
28446 if(!isWasmInitialized) {
28447 throw new Error("initializeWasm() must be awaited first!");
28449 const nativeResponseValue = wasm.TS_NodeId_hash(o);
28450 return nativeResponseValue;
28452 // struct LDKCVec_u8Z NodeId_write(const struct LDKNodeId *NONNULL_PTR obj);
28454 export function NodeId_write(obj: number): number {
28455 if(!isWasmInitialized) {
28456 throw new Error("initializeWasm() must be awaited first!");
28458 const nativeResponseValue = wasm.TS_NodeId_write(obj);
28459 return nativeResponseValue;
28461 // struct LDKCResult_NodeIdDecodeErrorZ NodeId_read(struct LDKu8slice ser);
28463 export function NodeId_read(ser: number): number {
28464 if(!isWasmInitialized) {
28465 throw new Error("initializeWasm() must be awaited first!");
28467 const nativeResponseValue = wasm.TS_NodeId_read(ser);
28468 return nativeResponseValue;
28470 // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
28472 export function NetworkGraph_free(this_obj: number): void {
28473 if(!isWasmInitialized) {
28474 throw new Error("initializeWasm() must be awaited first!");
28476 const nativeResponseValue = wasm.TS_NetworkGraph_free(this_obj);
28477 // debug statements here
28479 // void ReadOnlyNetworkGraph_free(struct LDKReadOnlyNetworkGraph this_obj);
28481 export function ReadOnlyNetworkGraph_free(this_obj: number): void {
28482 if(!isWasmInitialized) {
28483 throw new Error("initializeWasm() must be awaited first!");
28485 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_free(this_obj);
28486 // debug statements here
28488 // void NetworkUpdate_free(struct LDKNetworkUpdate this_ptr);
28490 export function NetworkUpdate_free(this_ptr: number): void {
28491 if(!isWasmInitialized) {
28492 throw new Error("initializeWasm() must be awaited first!");
28494 const nativeResponseValue = wasm.TS_NetworkUpdate_free(this_ptr);
28495 // debug statements here
28497 // uintptr_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg);
28499 export function NetworkUpdate_clone_ptr(arg: number): number {
28500 if(!isWasmInitialized) {
28501 throw new Error("initializeWasm() must be awaited first!");
28503 const nativeResponseValue = wasm.TS_NetworkUpdate_clone_ptr(arg);
28504 return nativeResponseValue;
28506 // struct LDKNetworkUpdate NetworkUpdate_clone(const struct LDKNetworkUpdate *NONNULL_PTR orig);
28508 export function NetworkUpdate_clone(orig: number): number {
28509 if(!isWasmInitialized) {
28510 throw new Error("initializeWasm() must be awaited first!");
28512 const nativeResponseValue = wasm.TS_NetworkUpdate_clone(orig);
28513 return nativeResponseValue;
28515 // struct LDKNetworkUpdate NetworkUpdate_channel_update_message(struct LDKChannelUpdate msg);
28517 export function NetworkUpdate_channel_update_message(msg: number): number {
28518 if(!isWasmInitialized) {
28519 throw new Error("initializeWasm() must be awaited first!");
28521 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_update_message(msg);
28522 return nativeResponseValue;
28524 // struct LDKNetworkUpdate NetworkUpdate_channel_failure(uint64_t short_channel_id, bool is_permanent);
28526 export function NetworkUpdate_channel_failure(short_channel_id: bigint, is_permanent: boolean): number {
28527 if(!isWasmInitialized) {
28528 throw new Error("initializeWasm() must be awaited first!");
28530 const nativeResponseValue = wasm.TS_NetworkUpdate_channel_failure(short_channel_id, is_permanent);
28531 return nativeResponseValue;
28533 // struct LDKNetworkUpdate NetworkUpdate_node_failure(struct LDKPublicKey node_id, bool is_permanent);
28535 export function NetworkUpdate_node_failure(node_id: number, is_permanent: boolean): number {
28536 if(!isWasmInitialized) {
28537 throw new Error("initializeWasm() must be awaited first!");
28539 const nativeResponseValue = wasm.TS_NetworkUpdate_node_failure(node_id, is_permanent);
28540 return nativeResponseValue;
28542 // struct LDKCVec_u8Z NetworkUpdate_write(const struct LDKNetworkUpdate *NONNULL_PTR obj);
28544 export function NetworkUpdate_write(obj: number): number {
28545 if(!isWasmInitialized) {
28546 throw new Error("initializeWasm() must be awaited first!");
28548 const nativeResponseValue = wasm.TS_NetworkUpdate_write(obj);
28549 return nativeResponseValue;
28551 // struct LDKCResult_COption_NetworkUpdateZDecodeErrorZ NetworkUpdate_read(struct LDKu8slice ser);
28553 export function NetworkUpdate_read(ser: number): number {
28554 if(!isWasmInitialized) {
28555 throw new Error("initializeWasm() must be awaited first!");
28557 const nativeResponseValue = wasm.TS_NetworkUpdate_read(ser);
28558 return nativeResponseValue;
28560 // void P2PGossipSync_free(struct LDKP2PGossipSync this_obj);
28562 export function P2PGossipSync_free(this_obj: number): void {
28563 if(!isWasmInitialized) {
28564 throw new Error("initializeWasm() must be awaited first!");
28566 const nativeResponseValue = wasm.TS_P2PGossipSync_free(this_obj);
28567 // debug statements here
28569 // MUST_USE_RES struct LDKP2PGossipSync P2PGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKCOption_AccessZ chain_access, struct LDKLogger logger);
28571 export function P2PGossipSync_new(network_graph: number, chain_access: number, logger: number): number {
28572 if(!isWasmInitialized) {
28573 throw new Error("initializeWasm() must be awaited first!");
28575 const nativeResponseValue = wasm.TS_P2PGossipSync_new(network_graph, chain_access, logger);
28576 return nativeResponseValue;
28578 // void P2PGossipSync_add_chain_access(struct LDKP2PGossipSync *NONNULL_PTR this_arg, struct LDKCOption_AccessZ chain_access);
28580 export function P2PGossipSync_add_chain_access(this_arg: number, chain_access: number): void {
28581 if(!isWasmInitialized) {
28582 throw new Error("initializeWasm() must be awaited first!");
28584 const nativeResponseValue = wasm.TS_P2PGossipSync_add_chain_access(this_arg, chain_access);
28585 // debug statements here
28587 // struct LDKEventHandler NetworkGraph_as_EventHandler(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
28589 export function NetworkGraph_as_EventHandler(this_arg: number): number {
28590 if(!isWasmInitialized) {
28591 throw new Error("initializeWasm() must be awaited first!");
28593 const nativeResponseValue = wasm.TS_NetworkGraph_as_EventHandler(this_arg);
28594 return nativeResponseValue;
28596 // struct LDKRoutingMessageHandler P2PGossipSync_as_RoutingMessageHandler(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
28598 export function P2PGossipSync_as_RoutingMessageHandler(this_arg: number): number {
28599 if(!isWasmInitialized) {
28600 throw new Error("initializeWasm() must be awaited first!");
28602 const nativeResponseValue = wasm.TS_P2PGossipSync_as_RoutingMessageHandler(this_arg);
28603 return nativeResponseValue;
28605 // struct LDKMessageSendEventsProvider P2PGossipSync_as_MessageSendEventsProvider(const struct LDKP2PGossipSync *NONNULL_PTR this_arg);
28607 export function P2PGossipSync_as_MessageSendEventsProvider(this_arg: number): number {
28608 if(!isWasmInitialized) {
28609 throw new Error("initializeWasm() must be awaited first!");
28611 const nativeResponseValue = wasm.TS_P2PGossipSync_as_MessageSendEventsProvider(this_arg);
28612 return nativeResponseValue;
28614 // void ChannelUpdateInfo_free(struct LDKChannelUpdateInfo this_obj);
28616 export function ChannelUpdateInfo_free(this_obj: number): void {
28617 if(!isWasmInitialized) {
28618 throw new Error("initializeWasm() must be awaited first!");
28620 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_free(this_obj);
28621 // debug statements here
28623 // uint32_t ChannelUpdateInfo_get_last_update(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28625 export function ChannelUpdateInfo_get_last_update(this_ptr: number): number {
28626 if(!isWasmInitialized) {
28627 throw new Error("initializeWasm() must be awaited first!");
28629 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update(this_ptr);
28630 return nativeResponseValue;
28632 // void ChannelUpdateInfo_set_last_update(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint32_t val);
28634 export function ChannelUpdateInfo_set_last_update(this_ptr: number, val: number): void {
28635 if(!isWasmInitialized) {
28636 throw new Error("initializeWasm() must be awaited first!");
28638 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update(this_ptr, val);
28639 // debug statements here
28641 // bool ChannelUpdateInfo_get_enabled(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28643 export function ChannelUpdateInfo_get_enabled(this_ptr: number): boolean {
28644 if(!isWasmInitialized) {
28645 throw new Error("initializeWasm() must be awaited first!");
28647 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_enabled(this_ptr);
28648 return nativeResponseValue;
28650 // void ChannelUpdateInfo_set_enabled(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, bool val);
28652 export function ChannelUpdateInfo_set_enabled(this_ptr: number, val: boolean): void {
28653 if(!isWasmInitialized) {
28654 throw new Error("initializeWasm() must be awaited first!");
28656 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_enabled(this_ptr, val);
28657 // debug statements here
28659 // uint16_t ChannelUpdateInfo_get_cltv_expiry_delta(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28661 export function ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr: number): number {
28662 if(!isWasmInitialized) {
28663 throw new Error("initializeWasm() must be awaited first!");
28665 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_cltv_expiry_delta(this_ptr);
28666 return nativeResponseValue;
28668 // void ChannelUpdateInfo_set_cltv_expiry_delta(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint16_t val);
28670 export function ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr: number, val: number): void {
28671 if(!isWasmInitialized) {
28672 throw new Error("initializeWasm() must be awaited first!");
28674 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_cltv_expiry_delta(this_ptr, val);
28675 // debug statements here
28677 // uint64_t ChannelUpdateInfo_get_htlc_minimum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28679 export function ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr: number): bigint {
28680 if(!isWasmInitialized) {
28681 throw new Error("initializeWasm() must be awaited first!");
28683 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_minimum_msat(this_ptr);
28684 return nativeResponseValue;
28686 // void ChannelUpdateInfo_set_htlc_minimum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, uint64_t val);
28688 export function ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr: number, val: bigint): void {
28689 if(!isWasmInitialized) {
28690 throw new Error("initializeWasm() must be awaited first!");
28692 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_minimum_msat(this_ptr, val);
28693 // debug statements here
28695 // struct LDKCOption_u64Z ChannelUpdateInfo_get_htlc_maximum_msat(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28697 export function ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr: number): number {
28698 if(!isWasmInitialized) {
28699 throw new Error("initializeWasm() must be awaited first!");
28701 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_htlc_maximum_msat(this_ptr);
28702 return nativeResponseValue;
28704 // void ChannelUpdateInfo_set_htlc_maximum_msat(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28706 export function ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr: number, val: number): void {
28707 if(!isWasmInitialized) {
28708 throw new Error("initializeWasm() must be awaited first!");
28710 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_htlc_maximum_msat(this_ptr, val);
28711 // debug statements here
28713 // struct LDKRoutingFees ChannelUpdateInfo_get_fees(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28715 export function ChannelUpdateInfo_get_fees(this_ptr: number): number {
28716 if(!isWasmInitialized) {
28717 throw new Error("initializeWasm() must be awaited first!");
28719 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_fees(this_ptr);
28720 return nativeResponseValue;
28722 // void ChannelUpdateInfo_set_fees(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
28724 export function ChannelUpdateInfo_set_fees(this_ptr: number, val: number): void {
28725 if(!isWasmInitialized) {
28726 throw new Error("initializeWasm() must be awaited first!");
28728 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_fees(this_ptr, val);
28729 // debug statements here
28731 // struct LDKChannelUpdate ChannelUpdateInfo_get_last_update_message(const struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr);
28733 export function ChannelUpdateInfo_get_last_update_message(this_ptr: number): number {
28734 if(!isWasmInitialized) {
28735 throw new Error("initializeWasm() must be awaited first!");
28737 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_get_last_update_message(this_ptr);
28738 return nativeResponseValue;
28740 // void ChannelUpdateInfo_set_last_update_message(struct LDKChannelUpdateInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdate val);
28742 export function ChannelUpdateInfo_set_last_update_message(this_ptr: number, val: number): void {
28743 if(!isWasmInitialized) {
28744 throw new Error("initializeWasm() must be awaited first!");
28746 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_set_last_update_message(this_ptr, val);
28747 // debug statements here
28749 // 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);
28751 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 {
28752 if(!isWasmInitialized) {
28753 throw new Error("initializeWasm() must be awaited first!");
28755 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);
28756 return nativeResponseValue;
28758 // uintptr_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg);
28760 export function ChannelUpdateInfo_clone_ptr(arg: number): number {
28761 if(!isWasmInitialized) {
28762 throw new Error("initializeWasm() must be awaited first!");
28764 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone_ptr(arg);
28765 return nativeResponseValue;
28767 // struct LDKChannelUpdateInfo ChannelUpdateInfo_clone(const struct LDKChannelUpdateInfo *NONNULL_PTR orig);
28769 export function ChannelUpdateInfo_clone(orig: number): number {
28770 if(!isWasmInitialized) {
28771 throw new Error("initializeWasm() must be awaited first!");
28773 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_clone(orig);
28774 return nativeResponseValue;
28776 // struct LDKCVec_u8Z ChannelUpdateInfo_write(const struct LDKChannelUpdateInfo *NONNULL_PTR obj);
28778 export function ChannelUpdateInfo_write(obj: number): number {
28779 if(!isWasmInitialized) {
28780 throw new Error("initializeWasm() must be awaited first!");
28782 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_write(obj);
28783 return nativeResponseValue;
28785 // struct LDKCResult_ChannelUpdateInfoDecodeErrorZ ChannelUpdateInfo_read(struct LDKu8slice ser);
28787 export function ChannelUpdateInfo_read(ser: number): number {
28788 if(!isWasmInitialized) {
28789 throw new Error("initializeWasm() must be awaited first!");
28791 const nativeResponseValue = wasm.TS_ChannelUpdateInfo_read(ser);
28792 return nativeResponseValue;
28794 // void ChannelInfo_free(struct LDKChannelInfo this_obj);
28796 export function ChannelInfo_free(this_obj: number): void {
28797 if(!isWasmInitialized) {
28798 throw new Error("initializeWasm() must be awaited first!");
28800 const nativeResponseValue = wasm.TS_ChannelInfo_free(this_obj);
28801 // debug statements here
28803 // struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28805 export function ChannelInfo_get_features(this_ptr: number): number {
28806 if(!isWasmInitialized) {
28807 throw new Error("initializeWasm() must be awaited first!");
28809 const nativeResponseValue = wasm.TS_ChannelInfo_get_features(this_ptr);
28810 return nativeResponseValue;
28812 // void ChannelInfo_set_features(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
28814 export function ChannelInfo_set_features(this_ptr: number, val: number): void {
28815 if(!isWasmInitialized) {
28816 throw new Error("initializeWasm() must be awaited first!");
28818 const nativeResponseValue = wasm.TS_ChannelInfo_set_features(this_ptr, val);
28819 // debug statements here
28821 // struct LDKNodeId ChannelInfo_get_node_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28823 export function ChannelInfo_get_node_one(this_ptr: number): number {
28824 if(!isWasmInitialized) {
28825 throw new Error("initializeWasm() must be awaited first!");
28827 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_one(this_ptr);
28828 return nativeResponseValue;
28830 // void ChannelInfo_set_node_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
28832 export function ChannelInfo_set_node_one(this_ptr: number, val: number): void {
28833 if(!isWasmInitialized) {
28834 throw new Error("initializeWasm() must be awaited first!");
28836 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_one(this_ptr, val);
28837 // debug statements here
28839 // struct LDKChannelUpdateInfo ChannelInfo_get_one_to_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28841 export function ChannelInfo_get_one_to_two(this_ptr: number): number {
28842 if(!isWasmInitialized) {
28843 throw new Error("initializeWasm() must be awaited first!");
28845 const nativeResponseValue = wasm.TS_ChannelInfo_get_one_to_two(this_ptr);
28846 return nativeResponseValue;
28848 // void ChannelInfo_set_one_to_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
28850 export function ChannelInfo_set_one_to_two(this_ptr: number, val: number): void {
28851 if(!isWasmInitialized) {
28852 throw new Error("initializeWasm() must be awaited first!");
28854 const nativeResponseValue = wasm.TS_ChannelInfo_set_one_to_two(this_ptr, val);
28855 // debug statements here
28857 // struct LDKNodeId ChannelInfo_get_node_two(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28859 export function ChannelInfo_get_node_two(this_ptr: number): number {
28860 if(!isWasmInitialized) {
28861 throw new Error("initializeWasm() must be awaited first!");
28863 const nativeResponseValue = wasm.TS_ChannelInfo_get_node_two(this_ptr);
28864 return nativeResponseValue;
28866 // void ChannelInfo_set_node_two(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKNodeId val);
28868 export function ChannelInfo_set_node_two(this_ptr: number, val: number): void {
28869 if(!isWasmInitialized) {
28870 throw new Error("initializeWasm() must be awaited first!");
28872 const nativeResponseValue = wasm.TS_ChannelInfo_set_node_two(this_ptr, val);
28873 // debug statements here
28875 // struct LDKChannelUpdateInfo ChannelInfo_get_two_to_one(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28877 export function ChannelInfo_get_two_to_one(this_ptr: number): number {
28878 if(!isWasmInitialized) {
28879 throw new Error("initializeWasm() must be awaited first!");
28881 const nativeResponseValue = wasm.TS_ChannelInfo_get_two_to_one(this_ptr);
28882 return nativeResponseValue;
28884 // void ChannelInfo_set_two_to_one(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelUpdateInfo val);
28886 export function ChannelInfo_set_two_to_one(this_ptr: number, val: number): void {
28887 if(!isWasmInitialized) {
28888 throw new Error("initializeWasm() must be awaited first!");
28890 const nativeResponseValue = wasm.TS_ChannelInfo_set_two_to_one(this_ptr, val);
28891 // debug statements here
28893 // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28895 export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
28896 if(!isWasmInitialized) {
28897 throw new Error("initializeWasm() must be awaited first!");
28899 const nativeResponseValue = wasm.TS_ChannelInfo_get_capacity_sats(this_ptr);
28900 return nativeResponseValue;
28902 // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
28904 export function ChannelInfo_set_capacity_sats(this_ptr: number, val: number): void {
28905 if(!isWasmInitialized) {
28906 throw new Error("initializeWasm() must be awaited first!");
28908 const nativeResponseValue = wasm.TS_ChannelInfo_set_capacity_sats(this_ptr, val);
28909 // debug statements here
28911 // struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
28913 export function ChannelInfo_get_announcement_message(this_ptr: number): number {
28914 if(!isWasmInitialized) {
28915 throw new Error("initializeWasm() must be awaited first!");
28917 const nativeResponseValue = wasm.TS_ChannelInfo_get_announcement_message(this_ptr);
28918 return nativeResponseValue;
28920 // void ChannelInfo_set_announcement_message(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKChannelAnnouncement val);
28922 export function ChannelInfo_set_announcement_message(this_ptr: number, val: number): void {
28923 if(!isWasmInitialized) {
28924 throw new Error("initializeWasm() must be awaited first!");
28926 const nativeResponseValue = wasm.TS_ChannelInfo_set_announcement_message(this_ptr, val);
28927 // debug statements here
28929 // uintptr_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg);
28931 export function ChannelInfo_clone_ptr(arg: number): number {
28932 if(!isWasmInitialized) {
28933 throw new Error("initializeWasm() must be awaited first!");
28935 const nativeResponseValue = wasm.TS_ChannelInfo_clone_ptr(arg);
28936 return nativeResponseValue;
28938 // struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
28940 export function ChannelInfo_clone(orig: number): number {
28941 if(!isWasmInitialized) {
28942 throw new Error("initializeWasm() must be awaited first!");
28944 const nativeResponseValue = wasm.TS_ChannelInfo_clone(orig);
28945 return nativeResponseValue;
28947 // MUST_USE_RES struct LDKChannelUpdateInfo ChannelInfo_get_directional_info(const struct LDKChannelInfo *NONNULL_PTR this_arg, uint8_t channel_flags);
28949 export function ChannelInfo_get_directional_info(this_arg: number, channel_flags: number): number {
28950 if(!isWasmInitialized) {
28951 throw new Error("initializeWasm() must be awaited first!");
28953 const nativeResponseValue = wasm.TS_ChannelInfo_get_directional_info(this_arg, channel_flags);
28954 return nativeResponseValue;
28956 // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj);
28958 export function ChannelInfo_write(obj: number): number {
28959 if(!isWasmInitialized) {
28960 throw new Error("initializeWasm() must be awaited first!");
28962 const nativeResponseValue = wasm.TS_ChannelInfo_write(obj);
28963 return nativeResponseValue;
28965 // struct LDKCResult_ChannelInfoDecodeErrorZ ChannelInfo_read(struct LDKu8slice ser);
28967 export function ChannelInfo_read(ser: number): number {
28968 if(!isWasmInitialized) {
28969 throw new Error("initializeWasm() must be awaited first!");
28971 const nativeResponseValue = wasm.TS_ChannelInfo_read(ser);
28972 return nativeResponseValue;
28974 // void DirectedChannelInfo_free(struct LDKDirectedChannelInfo this_obj);
28976 export function DirectedChannelInfo_free(this_obj: number): void {
28977 if(!isWasmInitialized) {
28978 throw new Error("initializeWasm() must be awaited first!");
28980 const nativeResponseValue = wasm.TS_DirectedChannelInfo_free(this_obj);
28981 // debug statements here
28983 // uintptr_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg);
28985 export function DirectedChannelInfo_clone_ptr(arg: number): number {
28986 if(!isWasmInitialized) {
28987 throw new Error("initializeWasm() must be awaited first!");
28989 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone_ptr(arg);
28990 return nativeResponseValue;
28992 // struct LDKDirectedChannelInfo DirectedChannelInfo_clone(const struct LDKDirectedChannelInfo *NONNULL_PTR orig);
28994 export function DirectedChannelInfo_clone(orig: number): number {
28995 if(!isWasmInitialized) {
28996 throw new Error("initializeWasm() must be awaited first!");
28998 const nativeResponseValue = wasm.TS_DirectedChannelInfo_clone(orig);
28999 return nativeResponseValue;
29001 // MUST_USE_RES struct LDKChannelInfo DirectedChannelInfo_channel(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29003 export function DirectedChannelInfo_channel(this_arg: number): number {
29004 if(!isWasmInitialized) {
29005 throw new Error("initializeWasm() must be awaited first!");
29007 const nativeResponseValue = wasm.TS_DirectedChannelInfo_channel(this_arg);
29008 return nativeResponseValue;
29010 // MUST_USE_RES struct LDKChannelUpdateInfo DirectedChannelInfo_direction(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29012 export function DirectedChannelInfo_direction(this_arg: number): number {
29013 if(!isWasmInitialized) {
29014 throw new Error("initializeWasm() must be awaited first!");
29016 const nativeResponseValue = wasm.TS_DirectedChannelInfo_direction(this_arg);
29017 return nativeResponseValue;
29019 // MUST_USE_RES uint64_t DirectedChannelInfo_htlc_maximum_msat(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29021 export function DirectedChannelInfo_htlc_maximum_msat(this_arg: number): bigint {
29022 if(!isWasmInitialized) {
29023 throw new Error("initializeWasm() must be awaited first!");
29025 const nativeResponseValue = wasm.TS_DirectedChannelInfo_htlc_maximum_msat(this_arg);
29026 return nativeResponseValue;
29028 // MUST_USE_RES struct LDKEffectiveCapacity DirectedChannelInfo_effective_capacity(const struct LDKDirectedChannelInfo *NONNULL_PTR this_arg);
29030 export function DirectedChannelInfo_effective_capacity(this_arg: number): number {
29031 if(!isWasmInitialized) {
29032 throw new Error("initializeWasm() must be awaited first!");
29034 const nativeResponseValue = wasm.TS_DirectedChannelInfo_effective_capacity(this_arg);
29035 return nativeResponseValue;
29037 // void EffectiveCapacity_free(struct LDKEffectiveCapacity this_ptr);
29039 export function EffectiveCapacity_free(this_ptr: number): void {
29040 if(!isWasmInitialized) {
29041 throw new Error("initializeWasm() must be awaited first!");
29043 const nativeResponseValue = wasm.TS_EffectiveCapacity_free(this_ptr);
29044 // debug statements here
29046 // uintptr_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg);
29048 export function EffectiveCapacity_clone_ptr(arg: number): number {
29049 if(!isWasmInitialized) {
29050 throw new Error("initializeWasm() must be awaited first!");
29052 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone_ptr(arg);
29053 return nativeResponseValue;
29055 // struct LDKEffectiveCapacity EffectiveCapacity_clone(const struct LDKEffectiveCapacity *NONNULL_PTR orig);
29057 export function EffectiveCapacity_clone(orig: number): number {
29058 if(!isWasmInitialized) {
29059 throw new Error("initializeWasm() must be awaited first!");
29061 const nativeResponseValue = wasm.TS_EffectiveCapacity_clone(orig);
29062 return nativeResponseValue;
29064 // struct LDKEffectiveCapacity EffectiveCapacity_exact_liquidity(uint64_t liquidity_msat);
29066 export function EffectiveCapacity_exact_liquidity(liquidity_msat: bigint): number {
29067 if(!isWasmInitialized) {
29068 throw new Error("initializeWasm() must be awaited first!");
29070 const nativeResponseValue = wasm.TS_EffectiveCapacity_exact_liquidity(liquidity_msat);
29071 return nativeResponseValue;
29073 // struct LDKEffectiveCapacity EffectiveCapacity_maximum_htlc(uint64_t amount_msat);
29075 export function EffectiveCapacity_maximum_htlc(amount_msat: bigint): number {
29076 if(!isWasmInitialized) {
29077 throw new Error("initializeWasm() must be awaited first!");
29079 const nativeResponseValue = wasm.TS_EffectiveCapacity_maximum_htlc(amount_msat);
29080 return nativeResponseValue;
29082 // struct LDKEffectiveCapacity EffectiveCapacity_total(uint64_t capacity_msat, struct LDKCOption_u64Z htlc_maximum_msat);
29084 export function EffectiveCapacity_total(capacity_msat: bigint, htlc_maximum_msat: number): number {
29085 if(!isWasmInitialized) {
29086 throw new Error("initializeWasm() must be awaited first!");
29088 const nativeResponseValue = wasm.TS_EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
29089 return nativeResponseValue;
29091 // struct LDKEffectiveCapacity EffectiveCapacity_infinite(void);
29093 export function EffectiveCapacity_infinite(): number {
29094 if(!isWasmInitialized) {
29095 throw new Error("initializeWasm() must be awaited first!");
29097 const nativeResponseValue = wasm.TS_EffectiveCapacity_infinite();
29098 return nativeResponseValue;
29100 // struct LDKEffectiveCapacity EffectiveCapacity_unknown(void);
29102 export function EffectiveCapacity_unknown(): number {
29103 if(!isWasmInitialized) {
29104 throw new Error("initializeWasm() must be awaited first!");
29106 const nativeResponseValue = wasm.TS_EffectiveCapacity_unknown();
29107 return nativeResponseValue;
29109 // MUST_USE_RES uint64_t EffectiveCapacity_as_msat(const struct LDKEffectiveCapacity *NONNULL_PTR this_arg);
29111 export function EffectiveCapacity_as_msat(this_arg: number): bigint {
29112 if(!isWasmInitialized) {
29113 throw new Error("initializeWasm() must be awaited first!");
29115 const nativeResponseValue = wasm.TS_EffectiveCapacity_as_msat(this_arg);
29116 return nativeResponseValue;
29118 // void RoutingFees_free(struct LDKRoutingFees this_obj);
29120 export function RoutingFees_free(this_obj: number): void {
29121 if(!isWasmInitialized) {
29122 throw new Error("initializeWasm() must be awaited first!");
29124 const nativeResponseValue = wasm.TS_RoutingFees_free(this_obj);
29125 // debug statements here
29127 // uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
29129 export function RoutingFees_get_base_msat(this_ptr: number): number {
29130 if(!isWasmInitialized) {
29131 throw new Error("initializeWasm() must be awaited first!");
29133 const nativeResponseValue = wasm.TS_RoutingFees_get_base_msat(this_ptr);
29134 return nativeResponseValue;
29136 // void RoutingFees_set_base_msat(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
29138 export function RoutingFees_set_base_msat(this_ptr: number, val: number): void {
29139 if(!isWasmInitialized) {
29140 throw new Error("initializeWasm() must be awaited first!");
29142 const nativeResponseValue = wasm.TS_RoutingFees_set_base_msat(this_ptr, val);
29143 // debug statements here
29145 // uint32_t RoutingFees_get_proportional_millionths(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
29147 export function RoutingFees_get_proportional_millionths(this_ptr: number): number {
29148 if(!isWasmInitialized) {
29149 throw new Error("initializeWasm() must be awaited first!");
29151 const nativeResponseValue = wasm.TS_RoutingFees_get_proportional_millionths(this_ptr);
29152 return nativeResponseValue;
29154 // void RoutingFees_set_proportional_millionths(struct LDKRoutingFees *NONNULL_PTR this_ptr, uint32_t val);
29156 export function RoutingFees_set_proportional_millionths(this_ptr: number, val: number): void {
29157 if(!isWasmInitialized) {
29158 throw new Error("initializeWasm() must be awaited first!");
29160 const nativeResponseValue = wasm.TS_RoutingFees_set_proportional_millionths(this_ptr, val);
29161 // debug statements here
29163 // MUST_USE_RES struct LDKRoutingFees RoutingFees_new(uint32_t base_msat_arg, uint32_t proportional_millionths_arg);
29165 export function RoutingFees_new(base_msat_arg: number, proportional_millionths_arg: number): number {
29166 if(!isWasmInitialized) {
29167 throw new Error("initializeWasm() must be awaited first!");
29169 const nativeResponseValue = wasm.TS_RoutingFees_new(base_msat_arg, proportional_millionths_arg);
29170 return nativeResponseValue;
29172 // bool RoutingFees_eq(const struct LDKRoutingFees *NONNULL_PTR a, const struct LDKRoutingFees *NONNULL_PTR b);
29174 export function RoutingFees_eq(a: number, b: number): boolean {
29175 if(!isWasmInitialized) {
29176 throw new Error("initializeWasm() must be awaited first!");
29178 const nativeResponseValue = wasm.TS_RoutingFees_eq(a, b);
29179 return nativeResponseValue;
29181 // uintptr_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg);
29183 export function RoutingFees_clone_ptr(arg: number): number {
29184 if(!isWasmInitialized) {
29185 throw new Error("initializeWasm() must be awaited first!");
29187 const nativeResponseValue = wasm.TS_RoutingFees_clone_ptr(arg);
29188 return nativeResponseValue;
29190 // struct LDKRoutingFees RoutingFees_clone(const struct LDKRoutingFees *NONNULL_PTR orig);
29192 export function RoutingFees_clone(orig: number): number {
29193 if(!isWasmInitialized) {
29194 throw new Error("initializeWasm() must be awaited first!");
29196 const nativeResponseValue = wasm.TS_RoutingFees_clone(orig);
29197 return nativeResponseValue;
29199 // uint64_t RoutingFees_hash(const struct LDKRoutingFees *NONNULL_PTR o);
29201 export function RoutingFees_hash(o: number): bigint {
29202 if(!isWasmInitialized) {
29203 throw new Error("initializeWasm() must be awaited first!");
29205 const nativeResponseValue = wasm.TS_RoutingFees_hash(o);
29206 return nativeResponseValue;
29208 // struct LDKCVec_u8Z RoutingFees_write(const struct LDKRoutingFees *NONNULL_PTR obj);
29210 export function RoutingFees_write(obj: number): number {
29211 if(!isWasmInitialized) {
29212 throw new Error("initializeWasm() must be awaited first!");
29214 const nativeResponseValue = wasm.TS_RoutingFees_write(obj);
29215 return nativeResponseValue;
29217 // struct LDKCResult_RoutingFeesDecodeErrorZ RoutingFees_read(struct LDKu8slice ser);
29219 export function RoutingFees_read(ser: number): number {
29220 if(!isWasmInitialized) {
29221 throw new Error("initializeWasm() must be awaited first!");
29223 const nativeResponseValue = wasm.TS_RoutingFees_read(ser);
29224 return nativeResponseValue;
29226 // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
29228 export function NodeAnnouncementInfo_free(this_obj: number): void {
29229 if(!isWasmInitialized) {
29230 throw new Error("initializeWasm() must be awaited first!");
29232 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_free(this_obj);
29233 // debug statements here
29235 // struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29237 export function NodeAnnouncementInfo_get_features(this_ptr: number): number {
29238 if(!isWasmInitialized) {
29239 throw new Error("initializeWasm() must be awaited first!");
29241 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_features(this_ptr);
29242 return nativeResponseValue;
29244 // void NodeAnnouncementInfo_set_features(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
29246 export function NodeAnnouncementInfo_set_features(this_ptr: number, val: number): void {
29247 if(!isWasmInitialized) {
29248 throw new Error("initializeWasm() must be awaited first!");
29250 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_features(this_ptr, val);
29251 // debug statements here
29253 // uint32_t NodeAnnouncementInfo_get_last_update(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29255 export function NodeAnnouncementInfo_get_last_update(this_ptr: number): number {
29256 if(!isWasmInitialized) {
29257 throw new Error("initializeWasm() must be awaited first!");
29259 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_last_update(this_ptr);
29260 return nativeResponseValue;
29262 // void NodeAnnouncementInfo_set_last_update(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, uint32_t val);
29264 export function NodeAnnouncementInfo_set_last_update(this_ptr: number, val: number): void {
29265 if(!isWasmInitialized) {
29266 throw new Error("initializeWasm() must be awaited first!");
29268 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_last_update(this_ptr, val);
29269 // debug statements here
29271 // const uint8_t (*NodeAnnouncementInfo_get_rgb(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr))[3];
29273 export function NodeAnnouncementInfo_get_rgb(this_ptr: number): number {
29274 if(!isWasmInitialized) {
29275 throw new Error("initializeWasm() must be awaited first!");
29277 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_rgb(this_ptr);
29278 return nativeResponseValue;
29280 // void NodeAnnouncementInfo_set_rgb(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKThreeBytes val);
29282 export function NodeAnnouncementInfo_set_rgb(this_ptr: number, val: number): void {
29283 if(!isWasmInitialized) {
29284 throw new Error("initializeWasm() must be awaited first!");
29286 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_rgb(this_ptr, val);
29287 // debug statements here
29289 // struct LDKNodeAlias NodeAnnouncementInfo_get_alias(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29291 export function NodeAnnouncementInfo_get_alias(this_ptr: number): number {
29292 if(!isWasmInitialized) {
29293 throw new Error("initializeWasm() must be awaited first!");
29295 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_alias(this_ptr);
29296 return nativeResponseValue;
29298 // void NodeAnnouncementInfo_set_alias(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAlias val);
29300 export function NodeAnnouncementInfo_set_alias(this_ptr: number, val: number): void {
29301 if(!isWasmInitialized) {
29302 throw new Error("initializeWasm() must be awaited first!");
29304 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_alias(this_ptr, val);
29305 // debug statements here
29307 // void NodeAnnouncementInfo_set_addresses(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKCVec_NetAddressZ val);
29309 export function NodeAnnouncementInfo_set_addresses(this_ptr: number, val: number): void {
29310 if(!isWasmInitialized) {
29311 throw new Error("initializeWasm() must be awaited first!");
29313 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_addresses(this_ptr, val);
29314 // debug statements here
29316 // struct LDKNodeAnnouncement NodeAnnouncementInfo_get_announcement_message(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
29318 export function NodeAnnouncementInfo_get_announcement_message(this_ptr: number): number {
29319 if(!isWasmInitialized) {
29320 throw new Error("initializeWasm() must be awaited first!");
29322 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_get_announcement_message(this_ptr);
29323 return nativeResponseValue;
29325 // void NodeAnnouncementInfo_set_announcement_message(struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncement val);
29327 export function NodeAnnouncementInfo_set_announcement_message(this_ptr: number, val: number): void {
29328 if(!isWasmInitialized) {
29329 throw new Error("initializeWasm() must be awaited first!");
29331 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_set_announcement_message(this_ptr, val);
29332 // debug statements here
29334 // MUST_USE_RES struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_new(struct LDKNodeFeatures features_arg, uint32_t last_update_arg, struct LDKThreeBytes rgb_arg, struct LDKNodeAlias alias_arg, struct LDKCVec_NetAddressZ addresses_arg, struct LDKNodeAnnouncement announcement_message_arg);
29336 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 {
29337 if(!isWasmInitialized) {
29338 throw new Error("initializeWasm() must be awaited first!");
29340 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_new(features_arg, last_update_arg, rgb_arg, alias_arg, addresses_arg, announcement_message_arg);
29341 return nativeResponseValue;
29343 // uintptr_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg);
29345 export function NodeAnnouncementInfo_clone_ptr(arg: number): number {
29346 if(!isWasmInitialized) {
29347 throw new Error("initializeWasm() must be awaited first!");
29349 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone_ptr(arg);
29350 return nativeResponseValue;
29352 // struct LDKNodeAnnouncementInfo NodeAnnouncementInfo_clone(const struct LDKNodeAnnouncementInfo *NONNULL_PTR orig);
29354 export function NodeAnnouncementInfo_clone(orig: number): number {
29355 if(!isWasmInitialized) {
29356 throw new Error("initializeWasm() must be awaited first!");
29358 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_clone(orig);
29359 return nativeResponseValue;
29361 // struct LDKCVec_u8Z NodeAnnouncementInfo_write(const struct LDKNodeAnnouncementInfo *NONNULL_PTR obj);
29363 export function NodeAnnouncementInfo_write(obj: number): number {
29364 if(!isWasmInitialized) {
29365 throw new Error("initializeWasm() must be awaited first!");
29367 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_write(obj);
29368 return nativeResponseValue;
29370 // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ NodeAnnouncementInfo_read(struct LDKu8slice ser);
29372 export function NodeAnnouncementInfo_read(ser: number): number {
29373 if(!isWasmInitialized) {
29374 throw new Error("initializeWasm() must be awaited first!");
29376 const nativeResponseValue = wasm.TS_NodeAnnouncementInfo_read(ser);
29377 return nativeResponseValue;
29379 // void NodeAlias_free(struct LDKNodeAlias this_obj);
29381 export function NodeAlias_free(this_obj: number): void {
29382 if(!isWasmInitialized) {
29383 throw new Error("initializeWasm() must be awaited first!");
29385 const nativeResponseValue = wasm.TS_NodeAlias_free(this_obj);
29386 // debug statements here
29388 // const uint8_t (*NodeAlias_get_a(const struct LDKNodeAlias *NONNULL_PTR this_ptr))[32];
29390 export function NodeAlias_get_a(this_ptr: number): number {
29391 if(!isWasmInitialized) {
29392 throw new Error("initializeWasm() must be awaited first!");
29394 const nativeResponseValue = wasm.TS_NodeAlias_get_a(this_ptr);
29395 return nativeResponseValue;
29397 // void NodeAlias_set_a(struct LDKNodeAlias *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
29399 export function NodeAlias_set_a(this_ptr: number, val: number): void {
29400 if(!isWasmInitialized) {
29401 throw new Error("initializeWasm() must be awaited first!");
29403 const nativeResponseValue = wasm.TS_NodeAlias_set_a(this_ptr, val);
29404 // debug statements here
29406 // MUST_USE_RES struct LDKNodeAlias NodeAlias_new(struct LDKThirtyTwoBytes a_arg);
29408 export function NodeAlias_new(a_arg: number): number {
29409 if(!isWasmInitialized) {
29410 throw new Error("initializeWasm() must be awaited first!");
29412 const nativeResponseValue = wasm.TS_NodeAlias_new(a_arg);
29413 return nativeResponseValue;
29415 // uintptr_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg);
29417 export function NodeAlias_clone_ptr(arg: number): number {
29418 if(!isWasmInitialized) {
29419 throw new Error("initializeWasm() must be awaited first!");
29421 const nativeResponseValue = wasm.TS_NodeAlias_clone_ptr(arg);
29422 return nativeResponseValue;
29424 // struct LDKNodeAlias NodeAlias_clone(const struct LDKNodeAlias *NONNULL_PTR orig);
29426 export function NodeAlias_clone(orig: number): number {
29427 if(!isWasmInitialized) {
29428 throw new Error("initializeWasm() must be awaited first!");
29430 const nativeResponseValue = wasm.TS_NodeAlias_clone(orig);
29431 return nativeResponseValue;
29433 // struct LDKCVec_u8Z NodeAlias_write(const struct LDKNodeAlias *NONNULL_PTR obj);
29435 export function NodeAlias_write(obj: number): number {
29436 if(!isWasmInitialized) {
29437 throw new Error("initializeWasm() must be awaited first!");
29439 const nativeResponseValue = wasm.TS_NodeAlias_write(obj);
29440 return nativeResponseValue;
29442 // struct LDKCResult_NodeAliasDecodeErrorZ NodeAlias_read(struct LDKu8slice ser);
29444 export function NodeAlias_read(ser: number): number {
29445 if(!isWasmInitialized) {
29446 throw new Error("initializeWasm() must be awaited first!");
29448 const nativeResponseValue = wasm.TS_NodeAlias_read(ser);
29449 return nativeResponseValue;
29451 // void NodeInfo_free(struct LDKNodeInfo this_obj);
29453 export function NodeInfo_free(this_obj: number): void {
29454 if(!isWasmInitialized) {
29455 throw new Error("initializeWasm() must be awaited first!");
29457 const nativeResponseValue = wasm.TS_NodeInfo_free(this_obj);
29458 // debug statements here
29460 // void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
29462 export function NodeInfo_set_channels(this_ptr: number, val: number): void {
29463 if(!isWasmInitialized) {
29464 throw new Error("initializeWasm() must be awaited first!");
29466 const nativeResponseValue = wasm.TS_NodeInfo_set_channels(this_ptr, val);
29467 // debug statements here
29469 // struct LDKRoutingFees NodeInfo_get_lowest_inbound_channel_fees(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
29471 export function NodeInfo_get_lowest_inbound_channel_fees(this_ptr: number): number {
29472 if(!isWasmInitialized) {
29473 throw new Error("initializeWasm() must be awaited first!");
29475 const nativeResponseValue = wasm.TS_NodeInfo_get_lowest_inbound_channel_fees(this_ptr);
29476 return nativeResponseValue;
29478 // void NodeInfo_set_lowest_inbound_channel_fees(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
29480 export function NodeInfo_set_lowest_inbound_channel_fees(this_ptr: number, val: number): void {
29481 if(!isWasmInitialized) {
29482 throw new Error("initializeWasm() must be awaited first!");
29484 const nativeResponseValue = wasm.TS_NodeInfo_set_lowest_inbound_channel_fees(this_ptr, val);
29485 // debug statements here
29487 // struct LDKNodeAnnouncementInfo NodeInfo_get_announcement_info(const struct LDKNodeInfo *NONNULL_PTR this_ptr);
29489 export function NodeInfo_get_announcement_info(this_ptr: number): number {
29490 if(!isWasmInitialized) {
29491 throw new Error("initializeWasm() must be awaited first!");
29493 const nativeResponseValue = wasm.TS_NodeInfo_get_announcement_info(this_ptr);
29494 return nativeResponseValue;
29496 // void NodeInfo_set_announcement_info(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKNodeAnnouncementInfo val);
29498 export function NodeInfo_set_announcement_info(this_ptr: number, val: number): void {
29499 if(!isWasmInitialized) {
29500 throw new Error("initializeWasm() must be awaited first!");
29502 const nativeResponseValue = wasm.TS_NodeInfo_set_announcement_info(this_ptr, val);
29503 // debug statements here
29505 // MUST_USE_RES struct LDKNodeInfo NodeInfo_new(struct LDKCVec_u64Z channels_arg, struct LDKRoutingFees lowest_inbound_channel_fees_arg, struct LDKNodeAnnouncementInfo announcement_info_arg);
29507 export function NodeInfo_new(channels_arg: number, lowest_inbound_channel_fees_arg: number, announcement_info_arg: number): number {
29508 if(!isWasmInitialized) {
29509 throw new Error("initializeWasm() must be awaited first!");
29511 const nativeResponseValue = wasm.TS_NodeInfo_new(channels_arg, lowest_inbound_channel_fees_arg, announcement_info_arg);
29512 return nativeResponseValue;
29514 // uintptr_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg);
29516 export function NodeInfo_clone_ptr(arg: number): number {
29517 if(!isWasmInitialized) {
29518 throw new Error("initializeWasm() must be awaited first!");
29520 const nativeResponseValue = wasm.TS_NodeInfo_clone_ptr(arg);
29521 return nativeResponseValue;
29523 // struct LDKNodeInfo NodeInfo_clone(const struct LDKNodeInfo *NONNULL_PTR orig);
29525 export function NodeInfo_clone(orig: number): number {
29526 if(!isWasmInitialized) {
29527 throw new Error("initializeWasm() must be awaited first!");
29529 const nativeResponseValue = wasm.TS_NodeInfo_clone(orig);
29530 return nativeResponseValue;
29532 // struct LDKCVec_u8Z NodeInfo_write(const struct LDKNodeInfo *NONNULL_PTR obj);
29534 export function NodeInfo_write(obj: number): number {
29535 if(!isWasmInitialized) {
29536 throw new Error("initializeWasm() must be awaited first!");
29538 const nativeResponseValue = wasm.TS_NodeInfo_write(obj);
29539 return nativeResponseValue;
29541 // struct LDKCResult_NodeInfoDecodeErrorZ NodeInfo_read(struct LDKu8slice ser);
29543 export function NodeInfo_read(ser: number): number {
29544 if(!isWasmInitialized) {
29545 throw new Error("initializeWasm() must be awaited first!");
29547 const nativeResponseValue = wasm.TS_NodeInfo_read(ser);
29548 return nativeResponseValue;
29550 // struct LDKCVec_u8Z NetworkGraph_write(const struct LDKNetworkGraph *NONNULL_PTR obj);
29552 export function NetworkGraph_write(obj: number): number {
29553 if(!isWasmInitialized) {
29554 throw new Error("initializeWasm() must be awaited first!");
29556 const nativeResponseValue = wasm.TS_NetworkGraph_write(obj);
29557 return nativeResponseValue;
29559 // struct LDKCResult_NetworkGraphDecodeErrorZ NetworkGraph_read(struct LDKu8slice ser, struct LDKLogger arg);
29561 export function NetworkGraph_read(ser: number, arg: number): number {
29562 if(!isWasmInitialized) {
29563 throw new Error("initializeWasm() must be awaited first!");
29565 const nativeResponseValue = wasm.TS_NetworkGraph_read(ser, arg);
29566 return nativeResponseValue;
29568 // MUST_USE_RES struct LDKNetworkGraph NetworkGraph_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKLogger logger);
29570 export function NetworkGraph_new(genesis_hash: number, logger: number): number {
29571 if(!isWasmInitialized) {
29572 throw new Error("initializeWasm() must be awaited first!");
29574 const nativeResponseValue = wasm.TS_NetworkGraph_new(genesis_hash, logger);
29575 return nativeResponseValue;
29577 // MUST_USE_RES struct LDKReadOnlyNetworkGraph NetworkGraph_read_only(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
29579 export function NetworkGraph_read_only(this_arg: number): number {
29580 if(!isWasmInitialized) {
29581 throw new Error("initializeWasm() must be awaited first!");
29583 const nativeResponseValue = wasm.TS_NetworkGraph_read_only(this_arg);
29584 return nativeResponseValue;
29586 // MUST_USE_RES struct LDKCOption_u32Z NetworkGraph_get_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg);
29588 export function NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg: number): number {
29589 if(!isWasmInitialized) {
29590 throw new Error("initializeWasm() must be awaited first!");
29592 const nativeResponseValue = wasm.TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(this_arg);
29593 return nativeResponseValue;
29595 // void NetworkGraph_set_last_rapid_gossip_sync_timestamp(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint32_t last_rapid_gossip_sync_timestamp);
29597 export function NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg: number, last_rapid_gossip_sync_timestamp: number): void {
29598 if(!isWasmInitialized) {
29599 throw new Error("initializeWasm() must be awaited first!");
29601 const nativeResponseValue = wasm.TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(this_arg, last_rapid_gossip_sync_timestamp);
29602 // debug statements here
29604 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_node_from_announcement(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg);
29606 export function NetworkGraph_update_node_from_announcement(this_arg: number, msg: number): number {
29607 if(!isWasmInitialized) {
29608 throw new Error("initializeWasm() must be awaited first!");
29610 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_announcement(this_arg, msg);
29611 return nativeResponseValue;
29613 // 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);
29615 export function NetworkGraph_update_node_from_unsigned_announcement(this_arg: number, msg: number): number {
29616 if(!isWasmInitialized) {
29617 throw new Error("initializeWasm() must be awaited first!");
29619 const nativeResponseValue = wasm.TS_NetworkGraph_update_node_from_unsigned_announcement(this_arg, msg);
29620 return nativeResponseValue;
29622 // 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);
29624 export function NetworkGraph_update_channel_from_announcement(this_arg: number, msg: number, chain_access: number): number {
29625 if(!isWasmInitialized) {
29626 throw new Error("initializeWasm() must be awaited first!");
29628 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_announcement(this_arg, msg, chain_access);
29629 return nativeResponseValue;
29631 // 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);
29633 export function NetworkGraph_update_channel_from_unsigned_announcement(this_arg: number, msg: number, chain_access: number): number {
29634 if(!isWasmInitialized) {
29635 throw new Error("initializeWasm() must be awaited first!");
29637 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_from_unsigned_announcement(this_arg, msg, chain_access);
29638 return nativeResponseValue;
29640 // 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);
29642 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 {
29643 if(!isWasmInitialized) {
29644 throw new Error("initializeWasm() must be awaited first!");
29646 const nativeResponseValue = wasm.TS_NetworkGraph_add_channel_from_partial_announcement(this_arg, short_channel_id, timestamp, features, node_id_1, node_id_2);
29647 return nativeResponseValue;
29649 // void NetworkGraph_channel_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t short_channel_id, bool is_permanent);
29651 export function NetworkGraph_channel_failed(this_arg: number, short_channel_id: bigint, is_permanent: boolean): void {
29652 if(!isWasmInitialized) {
29653 throw new Error("initializeWasm() must be awaited first!");
29655 const nativeResponseValue = wasm.TS_NetworkGraph_channel_failed(this_arg, short_channel_id, is_permanent);
29656 // debug statements here
29658 // void NetworkGraph_node_failed(const struct LDKNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey _node_id, bool is_permanent);
29660 export function NetworkGraph_node_failed(this_arg: number, _node_id: number, is_permanent: boolean): void {
29661 if(!isWasmInitialized) {
29662 throw new Error("initializeWasm() must be awaited first!");
29664 const nativeResponseValue = wasm.TS_NetworkGraph_node_failed(this_arg, _node_id, is_permanent);
29665 // debug statements here
29667 // void NetworkGraph_remove_stale_channels_with_time(const struct LDKNetworkGraph *NONNULL_PTR this_arg, uint64_t current_time_unix);
29669 export function NetworkGraph_remove_stale_channels_with_time(this_arg: number, current_time_unix: bigint): void {
29670 if(!isWasmInitialized) {
29671 throw new Error("initializeWasm() must be awaited first!");
29673 const nativeResponseValue = wasm.TS_NetworkGraph_remove_stale_channels_with_time(this_arg, current_time_unix);
29674 // debug statements here
29676 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg);
29678 export function NetworkGraph_update_channel(this_arg: number, msg: number): number {
29679 if(!isWasmInitialized) {
29680 throw new Error("initializeWasm() must be awaited first!");
29682 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel(this_arg, msg);
29683 return nativeResponseValue;
29685 // MUST_USE_RES struct LDKCResult_NoneLightningErrorZ NetworkGraph_update_channel_unsigned(const struct LDKNetworkGraph *NONNULL_PTR this_arg, const struct LDKUnsignedChannelUpdate *NONNULL_PTR msg);
29687 export function NetworkGraph_update_channel_unsigned(this_arg: number, msg: number): number {
29688 if(!isWasmInitialized) {
29689 throw new Error("initializeWasm() must be awaited first!");
29691 const nativeResponseValue = wasm.TS_NetworkGraph_update_channel_unsigned(this_arg, msg);
29692 return nativeResponseValue;
29694 // MUST_USE_RES struct LDKCOption_CVec_NetAddressZZ ReadOnlyNetworkGraph_get_addresses(const struct LDKReadOnlyNetworkGraph *NONNULL_PTR this_arg, struct LDKPublicKey pubkey);
29696 export function ReadOnlyNetworkGraph_get_addresses(this_arg: number, pubkey: number): number {
29697 if(!isWasmInitialized) {
29698 throw new Error("initializeWasm() must be awaited first!");
29700 const nativeResponseValue = wasm.TS_ReadOnlyNetworkGraph_get_addresses(this_arg, pubkey);
29701 return nativeResponseValue;
29703 // void RouteHop_free(struct LDKRouteHop this_obj);
29705 export function RouteHop_free(this_obj: number): void {
29706 if(!isWasmInitialized) {
29707 throw new Error("initializeWasm() must be awaited first!");
29709 const nativeResponseValue = wasm.TS_RouteHop_free(this_obj);
29710 // debug statements here
29712 // struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29714 export function RouteHop_get_pubkey(this_ptr: number): number {
29715 if(!isWasmInitialized) {
29716 throw new Error("initializeWasm() must be awaited first!");
29718 const nativeResponseValue = wasm.TS_RouteHop_get_pubkey(this_ptr);
29719 return nativeResponseValue;
29721 // void RouteHop_set_pubkey(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
29723 export function RouteHop_set_pubkey(this_ptr: number, val: number): void {
29724 if(!isWasmInitialized) {
29725 throw new Error("initializeWasm() must be awaited first!");
29727 const nativeResponseValue = wasm.TS_RouteHop_set_pubkey(this_ptr, val);
29728 // debug statements here
29730 // struct LDKNodeFeatures RouteHop_get_node_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29732 export function RouteHop_get_node_features(this_ptr: number): number {
29733 if(!isWasmInitialized) {
29734 throw new Error("initializeWasm() must be awaited first!");
29736 const nativeResponseValue = wasm.TS_RouteHop_get_node_features(this_ptr);
29737 return nativeResponseValue;
29739 // void RouteHop_set_node_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKNodeFeatures val);
29741 export function RouteHop_set_node_features(this_ptr: number, val: number): void {
29742 if(!isWasmInitialized) {
29743 throw new Error("initializeWasm() must be awaited first!");
29745 const nativeResponseValue = wasm.TS_RouteHop_set_node_features(this_ptr, val);
29746 // debug statements here
29748 // uint64_t RouteHop_get_short_channel_id(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29750 export function RouteHop_get_short_channel_id(this_ptr: number): bigint {
29751 if(!isWasmInitialized) {
29752 throw new Error("initializeWasm() must be awaited first!");
29754 const nativeResponseValue = wasm.TS_RouteHop_get_short_channel_id(this_ptr);
29755 return nativeResponseValue;
29757 // void RouteHop_set_short_channel_id(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
29759 export function RouteHop_set_short_channel_id(this_ptr: number, val: bigint): void {
29760 if(!isWasmInitialized) {
29761 throw new Error("initializeWasm() must be awaited first!");
29763 const nativeResponseValue = wasm.TS_RouteHop_set_short_channel_id(this_ptr, val);
29764 // debug statements here
29766 // struct LDKChannelFeatures RouteHop_get_channel_features(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29768 export function RouteHop_get_channel_features(this_ptr: number): number {
29769 if(!isWasmInitialized) {
29770 throw new Error("initializeWasm() must be awaited first!");
29772 const nativeResponseValue = wasm.TS_RouteHop_get_channel_features(this_ptr);
29773 return nativeResponseValue;
29775 // void RouteHop_set_channel_features(struct LDKRouteHop *NONNULL_PTR this_ptr, struct LDKChannelFeatures val);
29777 export function RouteHop_set_channel_features(this_ptr: number, val: number): void {
29778 if(!isWasmInitialized) {
29779 throw new Error("initializeWasm() must be awaited first!");
29781 const nativeResponseValue = wasm.TS_RouteHop_set_channel_features(this_ptr, val);
29782 // debug statements here
29784 // uint64_t RouteHop_get_fee_msat(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29786 export function RouteHop_get_fee_msat(this_ptr: number): bigint {
29787 if(!isWasmInitialized) {
29788 throw new Error("initializeWasm() must be awaited first!");
29790 const nativeResponseValue = wasm.TS_RouteHop_get_fee_msat(this_ptr);
29791 return nativeResponseValue;
29793 // void RouteHop_set_fee_msat(struct LDKRouteHop *NONNULL_PTR this_ptr, uint64_t val);
29795 export function RouteHop_set_fee_msat(this_ptr: number, val: bigint): void {
29796 if(!isWasmInitialized) {
29797 throw new Error("initializeWasm() must be awaited first!");
29799 const nativeResponseValue = wasm.TS_RouteHop_set_fee_msat(this_ptr, val);
29800 // debug statements here
29802 // uint32_t RouteHop_get_cltv_expiry_delta(const struct LDKRouteHop *NONNULL_PTR this_ptr);
29804 export function RouteHop_get_cltv_expiry_delta(this_ptr: number): number {
29805 if(!isWasmInitialized) {
29806 throw new Error("initializeWasm() must be awaited first!");
29808 const nativeResponseValue = wasm.TS_RouteHop_get_cltv_expiry_delta(this_ptr);
29809 return nativeResponseValue;
29811 // void RouteHop_set_cltv_expiry_delta(struct LDKRouteHop *NONNULL_PTR this_ptr, uint32_t val);
29813 export function RouteHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
29814 if(!isWasmInitialized) {
29815 throw new Error("initializeWasm() must be awaited first!");
29817 const nativeResponseValue = wasm.TS_RouteHop_set_cltv_expiry_delta(this_ptr, val);
29818 // debug statements here
29820 // 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);
29822 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 {
29823 if(!isWasmInitialized) {
29824 throw new Error("initializeWasm() must be awaited first!");
29826 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);
29827 return nativeResponseValue;
29829 // uintptr_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg);
29831 export function RouteHop_clone_ptr(arg: number): number {
29832 if(!isWasmInitialized) {
29833 throw new Error("initializeWasm() must be awaited first!");
29835 const nativeResponseValue = wasm.TS_RouteHop_clone_ptr(arg);
29836 return nativeResponseValue;
29838 // struct LDKRouteHop RouteHop_clone(const struct LDKRouteHop *NONNULL_PTR orig);
29840 export function RouteHop_clone(orig: number): number {
29841 if(!isWasmInitialized) {
29842 throw new Error("initializeWasm() must be awaited first!");
29844 const nativeResponseValue = wasm.TS_RouteHop_clone(orig);
29845 return nativeResponseValue;
29847 // uint64_t RouteHop_hash(const struct LDKRouteHop *NONNULL_PTR o);
29849 export function RouteHop_hash(o: number): bigint {
29850 if(!isWasmInitialized) {
29851 throw new Error("initializeWasm() must be awaited first!");
29853 const nativeResponseValue = wasm.TS_RouteHop_hash(o);
29854 return nativeResponseValue;
29856 // bool RouteHop_eq(const struct LDKRouteHop *NONNULL_PTR a, const struct LDKRouteHop *NONNULL_PTR b);
29858 export function RouteHop_eq(a: number, b: number): boolean {
29859 if(!isWasmInitialized) {
29860 throw new Error("initializeWasm() must be awaited first!");
29862 const nativeResponseValue = wasm.TS_RouteHop_eq(a, b);
29863 return nativeResponseValue;
29865 // struct LDKCVec_u8Z RouteHop_write(const struct LDKRouteHop *NONNULL_PTR obj);
29867 export function RouteHop_write(obj: number): number {
29868 if(!isWasmInitialized) {
29869 throw new Error("initializeWasm() must be awaited first!");
29871 const nativeResponseValue = wasm.TS_RouteHop_write(obj);
29872 return nativeResponseValue;
29874 // struct LDKCResult_RouteHopDecodeErrorZ RouteHop_read(struct LDKu8slice ser);
29876 export function RouteHop_read(ser: number): number {
29877 if(!isWasmInitialized) {
29878 throw new Error("initializeWasm() must be awaited first!");
29880 const nativeResponseValue = wasm.TS_RouteHop_read(ser);
29881 return nativeResponseValue;
29883 // void Route_free(struct LDKRoute this_obj);
29885 export function Route_free(this_obj: number): void {
29886 if(!isWasmInitialized) {
29887 throw new Error("initializeWasm() must be awaited first!");
29889 const nativeResponseValue = wasm.TS_Route_free(this_obj);
29890 // debug statements here
29892 // struct LDKCVec_CVec_RouteHopZZ Route_get_paths(const struct LDKRoute *NONNULL_PTR this_ptr);
29894 export function Route_get_paths(this_ptr: number): number {
29895 if(!isWasmInitialized) {
29896 throw new Error("initializeWasm() must be awaited first!");
29898 const nativeResponseValue = wasm.TS_Route_get_paths(this_ptr);
29899 return nativeResponseValue;
29901 // void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
29903 export function Route_set_paths(this_ptr: number, val: number): void {
29904 if(!isWasmInitialized) {
29905 throw new Error("initializeWasm() must be awaited first!");
29907 const nativeResponseValue = wasm.TS_Route_set_paths(this_ptr, val);
29908 // debug statements here
29910 // struct LDKPaymentParameters Route_get_payment_params(const struct LDKRoute *NONNULL_PTR this_ptr);
29912 export function Route_get_payment_params(this_ptr: number): number {
29913 if(!isWasmInitialized) {
29914 throw new Error("initializeWasm() must be awaited first!");
29916 const nativeResponseValue = wasm.TS_Route_get_payment_params(this_ptr);
29917 return nativeResponseValue;
29919 // void Route_set_payment_params(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
29921 export function Route_set_payment_params(this_ptr: number, val: number): void {
29922 if(!isWasmInitialized) {
29923 throw new Error("initializeWasm() must be awaited first!");
29925 const nativeResponseValue = wasm.TS_Route_set_payment_params(this_ptr, val);
29926 // debug statements here
29928 // MUST_USE_RES struct LDKRoute Route_new(struct LDKCVec_CVec_RouteHopZZ paths_arg, struct LDKPaymentParameters payment_params_arg);
29930 export function Route_new(paths_arg: number, payment_params_arg: number): number {
29931 if(!isWasmInitialized) {
29932 throw new Error("initializeWasm() must be awaited first!");
29934 const nativeResponseValue = wasm.TS_Route_new(paths_arg, payment_params_arg);
29935 return nativeResponseValue;
29937 // uintptr_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg);
29939 export function Route_clone_ptr(arg: number): number {
29940 if(!isWasmInitialized) {
29941 throw new Error("initializeWasm() must be awaited first!");
29943 const nativeResponseValue = wasm.TS_Route_clone_ptr(arg);
29944 return nativeResponseValue;
29946 // struct LDKRoute Route_clone(const struct LDKRoute *NONNULL_PTR orig);
29948 export function Route_clone(orig: number): number {
29949 if(!isWasmInitialized) {
29950 throw new Error("initializeWasm() must be awaited first!");
29952 const nativeResponseValue = wasm.TS_Route_clone(orig);
29953 return nativeResponseValue;
29955 // uint64_t Route_hash(const struct LDKRoute *NONNULL_PTR o);
29957 export function Route_hash(o: number): bigint {
29958 if(!isWasmInitialized) {
29959 throw new Error("initializeWasm() must be awaited first!");
29961 const nativeResponseValue = wasm.TS_Route_hash(o);
29962 return nativeResponseValue;
29964 // bool Route_eq(const struct LDKRoute *NONNULL_PTR a, const struct LDKRoute *NONNULL_PTR b);
29966 export function Route_eq(a: number, b: number): boolean {
29967 if(!isWasmInitialized) {
29968 throw new Error("initializeWasm() must be awaited first!");
29970 const nativeResponseValue = wasm.TS_Route_eq(a, b);
29971 return nativeResponseValue;
29973 // MUST_USE_RES uint64_t Route_get_total_fees(const struct LDKRoute *NONNULL_PTR this_arg);
29975 export function Route_get_total_fees(this_arg: number): bigint {
29976 if(!isWasmInitialized) {
29977 throw new Error("initializeWasm() must be awaited first!");
29979 const nativeResponseValue = wasm.TS_Route_get_total_fees(this_arg);
29980 return nativeResponseValue;
29982 // MUST_USE_RES uint64_t Route_get_total_amount(const struct LDKRoute *NONNULL_PTR this_arg);
29984 export function Route_get_total_amount(this_arg: number): bigint {
29985 if(!isWasmInitialized) {
29986 throw new Error("initializeWasm() must be awaited first!");
29988 const nativeResponseValue = wasm.TS_Route_get_total_amount(this_arg);
29989 return nativeResponseValue;
29991 // struct LDKCVec_u8Z Route_write(const struct LDKRoute *NONNULL_PTR obj);
29993 export function Route_write(obj: number): number {
29994 if(!isWasmInitialized) {
29995 throw new Error("initializeWasm() must be awaited first!");
29997 const nativeResponseValue = wasm.TS_Route_write(obj);
29998 return nativeResponseValue;
30000 // struct LDKCResult_RouteDecodeErrorZ Route_read(struct LDKu8slice ser);
30002 export function Route_read(ser: number): number {
30003 if(!isWasmInitialized) {
30004 throw new Error("initializeWasm() must be awaited first!");
30006 const nativeResponseValue = wasm.TS_Route_read(ser);
30007 return nativeResponseValue;
30009 // void RouteParameters_free(struct LDKRouteParameters this_obj);
30011 export function RouteParameters_free(this_obj: number): void {
30012 if(!isWasmInitialized) {
30013 throw new Error("initializeWasm() must be awaited first!");
30015 const nativeResponseValue = wasm.TS_RouteParameters_free(this_obj);
30016 // debug statements here
30018 // struct LDKPaymentParameters RouteParameters_get_payment_params(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30020 export function RouteParameters_get_payment_params(this_ptr: number): number {
30021 if(!isWasmInitialized) {
30022 throw new Error("initializeWasm() must be awaited first!");
30024 const nativeResponseValue = wasm.TS_RouteParameters_get_payment_params(this_ptr);
30025 return nativeResponseValue;
30027 // void RouteParameters_set_payment_params(struct LDKRouteParameters *NONNULL_PTR this_ptr, struct LDKPaymentParameters val);
30029 export function RouteParameters_set_payment_params(this_ptr: number, val: number): void {
30030 if(!isWasmInitialized) {
30031 throw new Error("initializeWasm() must be awaited first!");
30033 const nativeResponseValue = wasm.TS_RouteParameters_set_payment_params(this_ptr, val);
30034 // debug statements here
30036 // uint64_t RouteParameters_get_final_value_msat(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30038 export function RouteParameters_get_final_value_msat(this_ptr: number): bigint {
30039 if(!isWasmInitialized) {
30040 throw new Error("initializeWasm() must be awaited first!");
30042 const nativeResponseValue = wasm.TS_RouteParameters_get_final_value_msat(this_ptr);
30043 return nativeResponseValue;
30045 // void RouteParameters_set_final_value_msat(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint64_t val);
30047 export function RouteParameters_set_final_value_msat(this_ptr: number, val: bigint): void {
30048 if(!isWasmInitialized) {
30049 throw new Error("initializeWasm() must be awaited first!");
30051 const nativeResponseValue = wasm.TS_RouteParameters_set_final_value_msat(this_ptr, val);
30052 // debug statements here
30054 // uint32_t RouteParameters_get_final_cltv_expiry_delta(const struct LDKRouteParameters *NONNULL_PTR this_ptr);
30056 export function RouteParameters_get_final_cltv_expiry_delta(this_ptr: number): number {
30057 if(!isWasmInitialized) {
30058 throw new Error("initializeWasm() must be awaited first!");
30060 const nativeResponseValue = wasm.TS_RouteParameters_get_final_cltv_expiry_delta(this_ptr);
30061 return nativeResponseValue;
30063 // void RouteParameters_set_final_cltv_expiry_delta(struct LDKRouteParameters *NONNULL_PTR this_ptr, uint32_t val);
30065 export function RouteParameters_set_final_cltv_expiry_delta(this_ptr: number, val: number): void {
30066 if(!isWasmInitialized) {
30067 throw new Error("initializeWasm() must be awaited first!");
30069 const nativeResponseValue = wasm.TS_RouteParameters_set_final_cltv_expiry_delta(this_ptr, val);
30070 // debug statements here
30072 // 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);
30074 export function RouteParameters_new(payment_params_arg: number, final_value_msat_arg: bigint, final_cltv_expiry_delta_arg: number): number {
30075 if(!isWasmInitialized) {
30076 throw new Error("initializeWasm() must be awaited first!");
30078 const nativeResponseValue = wasm.TS_RouteParameters_new(payment_params_arg, final_value_msat_arg, final_cltv_expiry_delta_arg);
30079 return nativeResponseValue;
30081 // uintptr_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg);
30083 export function RouteParameters_clone_ptr(arg: number): number {
30084 if(!isWasmInitialized) {
30085 throw new Error("initializeWasm() must be awaited first!");
30087 const nativeResponseValue = wasm.TS_RouteParameters_clone_ptr(arg);
30088 return nativeResponseValue;
30090 // struct LDKRouteParameters RouteParameters_clone(const struct LDKRouteParameters *NONNULL_PTR orig);
30092 export function RouteParameters_clone(orig: number): number {
30093 if(!isWasmInitialized) {
30094 throw new Error("initializeWasm() must be awaited first!");
30096 const nativeResponseValue = wasm.TS_RouteParameters_clone(orig);
30097 return nativeResponseValue;
30099 // struct LDKCVec_u8Z RouteParameters_write(const struct LDKRouteParameters *NONNULL_PTR obj);
30101 export function RouteParameters_write(obj: number): number {
30102 if(!isWasmInitialized) {
30103 throw new Error("initializeWasm() must be awaited first!");
30105 const nativeResponseValue = wasm.TS_RouteParameters_write(obj);
30106 return nativeResponseValue;
30108 // struct LDKCResult_RouteParametersDecodeErrorZ RouteParameters_read(struct LDKu8slice ser);
30110 export function RouteParameters_read(ser: number): number {
30111 if(!isWasmInitialized) {
30112 throw new Error("initializeWasm() must be awaited first!");
30114 const nativeResponseValue = wasm.TS_RouteParameters_read(ser);
30115 return nativeResponseValue;
30117 // void PaymentParameters_free(struct LDKPaymentParameters this_obj);
30119 export function PaymentParameters_free(this_obj: number): void {
30120 if(!isWasmInitialized) {
30121 throw new Error("initializeWasm() must be awaited first!");
30123 const nativeResponseValue = wasm.TS_PaymentParameters_free(this_obj);
30124 // debug statements here
30126 // struct LDKPublicKey PaymentParameters_get_payee_pubkey(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30128 export function PaymentParameters_get_payee_pubkey(this_ptr: number): number {
30129 if(!isWasmInitialized) {
30130 throw new Error("initializeWasm() must be awaited first!");
30132 const nativeResponseValue = wasm.TS_PaymentParameters_get_payee_pubkey(this_ptr);
30133 return nativeResponseValue;
30135 // void PaymentParameters_set_payee_pubkey(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30137 export function PaymentParameters_set_payee_pubkey(this_ptr: number, val: number): void {
30138 if(!isWasmInitialized) {
30139 throw new Error("initializeWasm() must be awaited first!");
30141 const nativeResponseValue = wasm.TS_PaymentParameters_set_payee_pubkey(this_ptr, val);
30142 // debug statements here
30144 // struct LDKInvoiceFeatures PaymentParameters_get_features(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30146 export function PaymentParameters_get_features(this_ptr: number): number {
30147 if(!isWasmInitialized) {
30148 throw new Error("initializeWasm() must be awaited first!");
30150 const nativeResponseValue = wasm.TS_PaymentParameters_get_features(this_ptr);
30151 return nativeResponseValue;
30153 // void PaymentParameters_set_features(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKInvoiceFeatures val);
30155 export function PaymentParameters_set_features(this_ptr: number, val: number): void {
30156 if(!isWasmInitialized) {
30157 throw new Error("initializeWasm() must be awaited first!");
30159 const nativeResponseValue = wasm.TS_PaymentParameters_set_features(this_ptr, val);
30160 // debug statements here
30162 // struct LDKCVec_RouteHintZ PaymentParameters_get_route_hints(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30164 export function PaymentParameters_get_route_hints(this_ptr: number): number {
30165 if(!isWasmInitialized) {
30166 throw new Error("initializeWasm() must be awaited first!");
30168 const nativeResponseValue = wasm.TS_PaymentParameters_get_route_hints(this_ptr);
30169 return nativeResponseValue;
30171 // void PaymentParameters_set_route_hints(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintZ val);
30173 export function PaymentParameters_set_route_hints(this_ptr: number, val: number): void {
30174 if(!isWasmInitialized) {
30175 throw new Error("initializeWasm() must be awaited first!");
30177 const nativeResponseValue = wasm.TS_PaymentParameters_set_route_hints(this_ptr, val);
30178 // debug statements here
30180 // struct LDKCOption_u64Z PaymentParameters_get_expiry_time(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30182 export function PaymentParameters_get_expiry_time(this_ptr: number): number {
30183 if(!isWasmInitialized) {
30184 throw new Error("initializeWasm() must be awaited first!");
30186 const nativeResponseValue = wasm.TS_PaymentParameters_get_expiry_time(this_ptr);
30187 return nativeResponseValue;
30189 // void PaymentParameters_set_expiry_time(struct LDKPaymentParameters *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30191 export function PaymentParameters_set_expiry_time(this_ptr: number, val: number): void {
30192 if(!isWasmInitialized) {
30193 throw new Error("initializeWasm() must be awaited first!");
30195 const nativeResponseValue = wasm.TS_PaymentParameters_set_expiry_time(this_ptr, val);
30196 // debug statements here
30198 // uint32_t PaymentParameters_get_max_total_cltv_expiry_delta(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30200 export function PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr: number): number {
30201 if(!isWasmInitialized) {
30202 throw new Error("initializeWasm() must be awaited first!");
30204 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_total_cltv_expiry_delta(this_ptr);
30205 return nativeResponseValue;
30207 // void PaymentParameters_set_max_total_cltv_expiry_delta(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint32_t val);
30209 export function PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr: number, val: number): void {
30210 if(!isWasmInitialized) {
30211 throw new Error("initializeWasm() must be awaited first!");
30213 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_total_cltv_expiry_delta(this_ptr, val);
30214 // debug statements here
30216 // uint8_t PaymentParameters_get_max_mpp_path_count(const struct LDKPaymentParameters *NONNULL_PTR this_ptr);
30218 export function PaymentParameters_get_max_mpp_path_count(this_ptr: number): number {
30219 if(!isWasmInitialized) {
30220 throw new Error("initializeWasm() must be awaited first!");
30222 const nativeResponseValue = wasm.TS_PaymentParameters_get_max_mpp_path_count(this_ptr);
30223 return nativeResponseValue;
30225 // void PaymentParameters_set_max_mpp_path_count(struct LDKPaymentParameters *NONNULL_PTR this_ptr, uint8_t val);
30227 export function PaymentParameters_set_max_mpp_path_count(this_ptr: number, val: number): void {
30228 if(!isWasmInitialized) {
30229 throw new Error("initializeWasm() must be awaited first!");
30231 const nativeResponseValue = wasm.TS_PaymentParameters_set_max_mpp_path_count(this_ptr, val);
30232 // debug statements here
30234 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_new(struct LDKPublicKey payee_pubkey_arg, struct LDKInvoiceFeatures features_arg, struct LDKCVec_RouteHintZ route_hints_arg, struct LDKCOption_u64Z expiry_time_arg, uint32_t max_total_cltv_expiry_delta_arg, uint8_t max_mpp_path_count_arg);
30236 export function PaymentParameters_new(payee_pubkey_arg: number, features_arg: number, route_hints_arg: number, expiry_time_arg: number, max_total_cltv_expiry_delta_arg: number, max_mpp_path_count_arg: number): number {
30237 if(!isWasmInitialized) {
30238 throw new Error("initializeWasm() must be awaited first!");
30240 const nativeResponseValue = wasm.TS_PaymentParameters_new(payee_pubkey_arg, features_arg, route_hints_arg, expiry_time_arg, max_total_cltv_expiry_delta_arg, max_mpp_path_count_arg);
30241 return nativeResponseValue;
30243 // uintptr_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg);
30245 export function PaymentParameters_clone_ptr(arg: number): number {
30246 if(!isWasmInitialized) {
30247 throw new Error("initializeWasm() must be awaited first!");
30249 const nativeResponseValue = wasm.TS_PaymentParameters_clone_ptr(arg);
30250 return nativeResponseValue;
30252 // struct LDKPaymentParameters PaymentParameters_clone(const struct LDKPaymentParameters *NONNULL_PTR orig);
30254 export function PaymentParameters_clone(orig: number): number {
30255 if(!isWasmInitialized) {
30256 throw new Error("initializeWasm() must be awaited first!");
30258 const nativeResponseValue = wasm.TS_PaymentParameters_clone(orig);
30259 return nativeResponseValue;
30261 // uint64_t PaymentParameters_hash(const struct LDKPaymentParameters *NONNULL_PTR o);
30263 export function PaymentParameters_hash(o: number): bigint {
30264 if(!isWasmInitialized) {
30265 throw new Error("initializeWasm() must be awaited first!");
30267 const nativeResponseValue = wasm.TS_PaymentParameters_hash(o);
30268 return nativeResponseValue;
30270 // bool PaymentParameters_eq(const struct LDKPaymentParameters *NONNULL_PTR a, const struct LDKPaymentParameters *NONNULL_PTR b);
30272 export function PaymentParameters_eq(a: number, b: number): boolean {
30273 if(!isWasmInitialized) {
30274 throw new Error("initializeWasm() must be awaited first!");
30276 const nativeResponseValue = wasm.TS_PaymentParameters_eq(a, b);
30277 return nativeResponseValue;
30279 // struct LDKCVec_u8Z PaymentParameters_write(const struct LDKPaymentParameters *NONNULL_PTR obj);
30281 export function PaymentParameters_write(obj: number): number {
30282 if(!isWasmInitialized) {
30283 throw new Error("initializeWasm() must be awaited first!");
30285 const nativeResponseValue = wasm.TS_PaymentParameters_write(obj);
30286 return nativeResponseValue;
30288 // struct LDKCResult_PaymentParametersDecodeErrorZ PaymentParameters_read(struct LDKu8slice ser);
30290 export function PaymentParameters_read(ser: number): number {
30291 if(!isWasmInitialized) {
30292 throw new Error("initializeWasm() must be awaited first!");
30294 const nativeResponseValue = wasm.TS_PaymentParameters_read(ser);
30295 return nativeResponseValue;
30297 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_from_node_id(struct LDKPublicKey payee_pubkey);
30299 export function PaymentParameters_from_node_id(payee_pubkey: number): number {
30300 if(!isWasmInitialized) {
30301 throw new Error("initializeWasm() must be awaited first!");
30303 const nativeResponseValue = wasm.TS_PaymentParameters_from_node_id(payee_pubkey);
30304 return nativeResponseValue;
30306 // MUST_USE_RES struct LDKPaymentParameters PaymentParameters_for_keysend(struct LDKPublicKey payee_pubkey);
30308 export function PaymentParameters_for_keysend(payee_pubkey: number): number {
30309 if(!isWasmInitialized) {
30310 throw new Error("initializeWasm() must be awaited first!");
30312 const nativeResponseValue = wasm.TS_PaymentParameters_for_keysend(payee_pubkey);
30313 return nativeResponseValue;
30315 // void RouteHint_free(struct LDKRouteHint this_obj);
30317 export function RouteHint_free(this_obj: number): void {
30318 if(!isWasmInitialized) {
30319 throw new Error("initializeWasm() must be awaited first!");
30321 const nativeResponseValue = wasm.TS_RouteHint_free(this_obj);
30322 // debug statements here
30324 // struct LDKCVec_RouteHintHopZ RouteHint_get_a(const struct LDKRouteHint *NONNULL_PTR this_ptr);
30326 export function RouteHint_get_a(this_ptr: number): number {
30327 if(!isWasmInitialized) {
30328 throw new Error("initializeWasm() must be awaited first!");
30330 const nativeResponseValue = wasm.TS_RouteHint_get_a(this_ptr);
30331 return nativeResponseValue;
30333 // void RouteHint_set_a(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCVec_RouteHintHopZ val);
30335 export function RouteHint_set_a(this_ptr: number, val: number): void {
30336 if(!isWasmInitialized) {
30337 throw new Error("initializeWasm() must be awaited first!");
30339 const nativeResponseValue = wasm.TS_RouteHint_set_a(this_ptr, val);
30340 // debug statements here
30342 // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKCVec_RouteHintHopZ a_arg);
30344 export function RouteHint_new(a_arg: number): number {
30345 if(!isWasmInitialized) {
30346 throw new Error("initializeWasm() must be awaited first!");
30348 const nativeResponseValue = wasm.TS_RouteHint_new(a_arg);
30349 return nativeResponseValue;
30351 // uintptr_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg);
30353 export function RouteHint_clone_ptr(arg: number): number {
30354 if(!isWasmInitialized) {
30355 throw new Error("initializeWasm() must be awaited first!");
30357 const nativeResponseValue = wasm.TS_RouteHint_clone_ptr(arg);
30358 return nativeResponseValue;
30360 // struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
30362 export function RouteHint_clone(orig: number): number {
30363 if(!isWasmInitialized) {
30364 throw new Error("initializeWasm() must be awaited first!");
30366 const nativeResponseValue = wasm.TS_RouteHint_clone(orig);
30367 return nativeResponseValue;
30369 // uint64_t RouteHint_hash(const struct LDKRouteHint *NONNULL_PTR o);
30371 export function RouteHint_hash(o: number): bigint {
30372 if(!isWasmInitialized) {
30373 throw new Error("initializeWasm() must be awaited first!");
30375 const nativeResponseValue = wasm.TS_RouteHint_hash(o);
30376 return nativeResponseValue;
30378 // bool RouteHint_eq(const struct LDKRouteHint *NONNULL_PTR a, const struct LDKRouteHint *NONNULL_PTR b);
30380 export function RouteHint_eq(a: number, b: number): boolean {
30381 if(!isWasmInitialized) {
30382 throw new Error("initializeWasm() must be awaited first!");
30384 const nativeResponseValue = wasm.TS_RouteHint_eq(a, b);
30385 return nativeResponseValue;
30387 // struct LDKCVec_u8Z RouteHint_write(const struct LDKRouteHint *NONNULL_PTR obj);
30389 export function RouteHint_write(obj: number): number {
30390 if(!isWasmInitialized) {
30391 throw new Error("initializeWasm() must be awaited first!");
30393 const nativeResponseValue = wasm.TS_RouteHint_write(obj);
30394 return nativeResponseValue;
30396 // struct LDKCResult_RouteHintDecodeErrorZ RouteHint_read(struct LDKu8slice ser);
30398 export function RouteHint_read(ser: number): number {
30399 if(!isWasmInitialized) {
30400 throw new Error("initializeWasm() must be awaited first!");
30402 const nativeResponseValue = wasm.TS_RouteHint_read(ser);
30403 return nativeResponseValue;
30405 // void RouteHintHop_free(struct LDKRouteHintHop this_obj);
30407 export function RouteHintHop_free(this_obj: number): void {
30408 if(!isWasmInitialized) {
30409 throw new Error("initializeWasm() must be awaited first!");
30411 const nativeResponseValue = wasm.TS_RouteHintHop_free(this_obj);
30412 // debug statements here
30414 // struct LDKPublicKey RouteHintHop_get_src_node_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30416 export function RouteHintHop_get_src_node_id(this_ptr: number): number {
30417 if(!isWasmInitialized) {
30418 throw new Error("initializeWasm() must be awaited first!");
30420 const nativeResponseValue = wasm.TS_RouteHintHop_get_src_node_id(this_ptr);
30421 return nativeResponseValue;
30423 // void RouteHintHop_set_src_node_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKPublicKey val);
30425 export function RouteHintHop_set_src_node_id(this_ptr: number, val: number): void {
30426 if(!isWasmInitialized) {
30427 throw new Error("initializeWasm() must be awaited first!");
30429 const nativeResponseValue = wasm.TS_RouteHintHop_set_src_node_id(this_ptr, val);
30430 // debug statements here
30432 // uint64_t RouteHintHop_get_short_channel_id(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30434 export function RouteHintHop_get_short_channel_id(this_ptr: number): bigint {
30435 if(!isWasmInitialized) {
30436 throw new Error("initializeWasm() must be awaited first!");
30438 const nativeResponseValue = wasm.TS_RouteHintHop_get_short_channel_id(this_ptr);
30439 return nativeResponseValue;
30441 // void RouteHintHop_set_short_channel_id(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint64_t val);
30443 export function RouteHintHop_set_short_channel_id(this_ptr: number, val: bigint): void {
30444 if(!isWasmInitialized) {
30445 throw new Error("initializeWasm() must be awaited first!");
30447 const nativeResponseValue = wasm.TS_RouteHintHop_set_short_channel_id(this_ptr, val);
30448 // debug statements here
30450 // struct LDKRoutingFees RouteHintHop_get_fees(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30452 export function RouteHintHop_get_fees(this_ptr: number): number {
30453 if(!isWasmInitialized) {
30454 throw new Error("initializeWasm() must be awaited first!");
30456 const nativeResponseValue = wasm.TS_RouteHintHop_get_fees(this_ptr);
30457 return nativeResponseValue;
30459 // void RouteHintHop_set_fees(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKRoutingFees val);
30461 export function RouteHintHop_set_fees(this_ptr: number, val: number): void {
30462 if(!isWasmInitialized) {
30463 throw new Error("initializeWasm() must be awaited first!");
30465 const nativeResponseValue = wasm.TS_RouteHintHop_set_fees(this_ptr, val);
30466 // debug statements here
30468 // uint16_t RouteHintHop_get_cltv_expiry_delta(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30470 export function RouteHintHop_get_cltv_expiry_delta(this_ptr: number): number {
30471 if(!isWasmInitialized) {
30472 throw new Error("initializeWasm() must be awaited first!");
30474 const nativeResponseValue = wasm.TS_RouteHintHop_get_cltv_expiry_delta(this_ptr);
30475 return nativeResponseValue;
30477 // void RouteHintHop_set_cltv_expiry_delta(struct LDKRouteHintHop *NONNULL_PTR this_ptr, uint16_t val);
30479 export function RouteHintHop_set_cltv_expiry_delta(this_ptr: number, val: number): void {
30480 if(!isWasmInitialized) {
30481 throw new Error("initializeWasm() must be awaited first!");
30483 const nativeResponseValue = wasm.TS_RouteHintHop_set_cltv_expiry_delta(this_ptr, val);
30484 // debug statements here
30486 // struct LDKCOption_u64Z RouteHintHop_get_htlc_minimum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30488 export function RouteHintHop_get_htlc_minimum_msat(this_ptr: number): number {
30489 if(!isWasmInitialized) {
30490 throw new Error("initializeWasm() must be awaited first!");
30492 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_minimum_msat(this_ptr);
30493 return nativeResponseValue;
30495 // void RouteHintHop_set_htlc_minimum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30497 export function RouteHintHop_set_htlc_minimum_msat(this_ptr: number, val: number): void {
30498 if(!isWasmInitialized) {
30499 throw new Error("initializeWasm() must be awaited first!");
30501 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_minimum_msat(this_ptr, val);
30502 // debug statements here
30504 // struct LDKCOption_u64Z RouteHintHop_get_htlc_maximum_msat(const struct LDKRouteHintHop *NONNULL_PTR this_ptr);
30506 export function RouteHintHop_get_htlc_maximum_msat(this_ptr: number): number {
30507 if(!isWasmInitialized) {
30508 throw new Error("initializeWasm() must be awaited first!");
30510 const nativeResponseValue = wasm.TS_RouteHintHop_get_htlc_maximum_msat(this_ptr);
30511 return nativeResponseValue;
30513 // void RouteHintHop_set_htlc_maximum_msat(struct LDKRouteHintHop *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
30515 export function RouteHintHop_set_htlc_maximum_msat(this_ptr: number, val: number): void {
30516 if(!isWasmInitialized) {
30517 throw new Error("initializeWasm() must be awaited first!");
30519 const nativeResponseValue = wasm.TS_RouteHintHop_set_htlc_maximum_msat(this_ptr, val);
30520 // debug statements here
30522 // 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);
30524 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 {
30525 if(!isWasmInitialized) {
30526 throw new Error("initializeWasm() must be awaited first!");
30528 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);
30529 return nativeResponseValue;
30531 // uintptr_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg);
30533 export function RouteHintHop_clone_ptr(arg: number): number {
30534 if(!isWasmInitialized) {
30535 throw new Error("initializeWasm() must be awaited first!");
30537 const nativeResponseValue = wasm.TS_RouteHintHop_clone_ptr(arg);
30538 return nativeResponseValue;
30540 // struct LDKRouteHintHop RouteHintHop_clone(const struct LDKRouteHintHop *NONNULL_PTR orig);
30542 export function RouteHintHop_clone(orig: number): number {
30543 if(!isWasmInitialized) {
30544 throw new Error("initializeWasm() must be awaited first!");
30546 const nativeResponseValue = wasm.TS_RouteHintHop_clone(orig);
30547 return nativeResponseValue;
30549 // uint64_t RouteHintHop_hash(const struct LDKRouteHintHop *NONNULL_PTR o);
30551 export function RouteHintHop_hash(o: number): bigint {
30552 if(!isWasmInitialized) {
30553 throw new Error("initializeWasm() must be awaited first!");
30555 const nativeResponseValue = wasm.TS_RouteHintHop_hash(o);
30556 return nativeResponseValue;
30558 // bool RouteHintHop_eq(const struct LDKRouteHintHop *NONNULL_PTR a, const struct LDKRouteHintHop *NONNULL_PTR b);
30560 export function RouteHintHop_eq(a: number, b: number): boolean {
30561 if(!isWasmInitialized) {
30562 throw new Error("initializeWasm() must be awaited first!");
30564 const nativeResponseValue = wasm.TS_RouteHintHop_eq(a, b);
30565 return nativeResponseValue;
30567 // struct LDKCVec_u8Z RouteHintHop_write(const struct LDKRouteHintHop *NONNULL_PTR obj);
30569 export function RouteHintHop_write(obj: number): number {
30570 if(!isWasmInitialized) {
30571 throw new Error("initializeWasm() must be awaited first!");
30573 const nativeResponseValue = wasm.TS_RouteHintHop_write(obj);
30574 return nativeResponseValue;
30576 // struct LDKCResult_RouteHintHopDecodeErrorZ RouteHintHop_read(struct LDKu8slice ser);
30578 export function RouteHintHop_read(ser: number): number {
30579 if(!isWasmInitialized) {
30580 throw new Error("initializeWasm() must be awaited first!");
30582 const nativeResponseValue = wasm.TS_RouteHintHop_read(ser);
30583 return nativeResponseValue;
30585 // 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]);
30587 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 {
30588 if(!isWasmInitialized) {
30589 throw new Error("initializeWasm() must be awaited first!");
30591 const nativeResponseValue = wasm.TS_find_route(our_node_pubkey, route_params, network_graph, first_hops, logger, scorer, random_seed_bytes);
30592 return nativeResponseValue;
30594 // 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]);
30596 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 {
30597 if(!isWasmInitialized) {
30598 throw new Error("initializeWasm() must be awaited first!");
30600 const nativeResponseValue = wasm.TS_build_route_from_hops(our_node_pubkey, hops, route_params, network_graph, logger, random_seed_bytes);
30601 return nativeResponseValue;
30603 // void Score_free(struct LDKScore this_ptr);
30605 export function Score_free(this_ptr: number): void {
30606 if(!isWasmInitialized) {
30607 throw new Error("initializeWasm() must be awaited first!");
30609 const nativeResponseValue = wasm.TS_Score_free(this_ptr);
30610 // debug statements here
30612 // void LockableScore_free(struct LDKLockableScore this_ptr);
30614 export function LockableScore_free(this_ptr: number): void {
30615 if(!isWasmInitialized) {
30616 throw new Error("initializeWasm() must be awaited first!");
30618 const nativeResponseValue = wasm.TS_LockableScore_free(this_ptr);
30619 // debug statements here
30621 // void MultiThreadedLockableScore_free(struct LDKMultiThreadedLockableScore this_obj);
30623 export function MultiThreadedLockableScore_free(this_obj: number): void {
30624 if(!isWasmInitialized) {
30625 throw new Error("initializeWasm() must be awaited first!");
30627 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_free(this_obj);
30628 // debug statements here
30630 // struct LDKCVec_u8Z MultiThreadedLockableScore_write(const struct LDKMultiThreadedLockableScore *NONNULL_PTR obj);
30632 export function MultiThreadedLockableScore_write(obj: number): number {
30633 if(!isWasmInitialized) {
30634 throw new Error("initializeWasm() must be awaited first!");
30636 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_write(obj);
30637 return nativeResponseValue;
30639 // MUST_USE_RES struct LDKMultiThreadedLockableScore MultiThreadedLockableScore_new(struct LDKScore score);
30641 export function MultiThreadedLockableScore_new(score: number): number {
30642 if(!isWasmInitialized) {
30643 throw new Error("initializeWasm() must be awaited first!");
30645 const nativeResponseValue = wasm.TS_MultiThreadedLockableScore_new(score);
30646 return nativeResponseValue;
30648 // void ChannelUsage_free(struct LDKChannelUsage this_obj);
30650 export function ChannelUsage_free(this_obj: number): void {
30651 if(!isWasmInitialized) {
30652 throw new Error("initializeWasm() must be awaited first!");
30654 const nativeResponseValue = wasm.TS_ChannelUsage_free(this_obj);
30655 // debug statements here
30657 // uint64_t ChannelUsage_get_amount_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
30659 export function ChannelUsage_get_amount_msat(this_ptr: number): bigint {
30660 if(!isWasmInitialized) {
30661 throw new Error("initializeWasm() must be awaited first!");
30663 const nativeResponseValue = wasm.TS_ChannelUsage_get_amount_msat(this_ptr);
30664 return nativeResponseValue;
30666 // void ChannelUsage_set_amount_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
30668 export function ChannelUsage_set_amount_msat(this_ptr: number, val: bigint): void {
30669 if(!isWasmInitialized) {
30670 throw new Error("initializeWasm() must be awaited first!");
30672 const nativeResponseValue = wasm.TS_ChannelUsage_set_amount_msat(this_ptr, val);
30673 // debug statements here
30675 // uint64_t ChannelUsage_get_inflight_htlc_msat(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
30677 export function ChannelUsage_get_inflight_htlc_msat(this_ptr: number): bigint {
30678 if(!isWasmInitialized) {
30679 throw new Error("initializeWasm() must be awaited first!");
30681 const nativeResponseValue = wasm.TS_ChannelUsage_get_inflight_htlc_msat(this_ptr);
30682 return nativeResponseValue;
30684 // void ChannelUsage_set_inflight_htlc_msat(struct LDKChannelUsage *NONNULL_PTR this_ptr, uint64_t val);
30686 export function ChannelUsage_set_inflight_htlc_msat(this_ptr: number, val: bigint): void {
30687 if(!isWasmInitialized) {
30688 throw new Error("initializeWasm() must be awaited first!");
30690 const nativeResponseValue = wasm.TS_ChannelUsage_set_inflight_htlc_msat(this_ptr, val);
30691 // debug statements here
30693 // struct LDKEffectiveCapacity ChannelUsage_get_effective_capacity(const struct LDKChannelUsage *NONNULL_PTR this_ptr);
30695 export function ChannelUsage_get_effective_capacity(this_ptr: number): number {
30696 if(!isWasmInitialized) {
30697 throw new Error("initializeWasm() must be awaited first!");
30699 const nativeResponseValue = wasm.TS_ChannelUsage_get_effective_capacity(this_ptr);
30700 return nativeResponseValue;
30702 // void ChannelUsage_set_effective_capacity(struct LDKChannelUsage *NONNULL_PTR this_ptr, struct LDKEffectiveCapacity val);
30704 export function ChannelUsage_set_effective_capacity(this_ptr: number, val: number): void {
30705 if(!isWasmInitialized) {
30706 throw new Error("initializeWasm() must be awaited first!");
30708 const nativeResponseValue = wasm.TS_ChannelUsage_set_effective_capacity(this_ptr, val);
30709 // debug statements here
30711 // MUST_USE_RES struct LDKChannelUsage ChannelUsage_new(uint64_t amount_msat_arg, uint64_t inflight_htlc_msat_arg, struct LDKEffectiveCapacity effective_capacity_arg);
30713 export function ChannelUsage_new(amount_msat_arg: bigint, inflight_htlc_msat_arg: bigint, effective_capacity_arg: number): number {
30714 if(!isWasmInitialized) {
30715 throw new Error("initializeWasm() must be awaited first!");
30717 const nativeResponseValue = wasm.TS_ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg);
30718 return nativeResponseValue;
30720 // uintptr_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg);
30722 export function ChannelUsage_clone_ptr(arg: number): number {
30723 if(!isWasmInitialized) {
30724 throw new Error("initializeWasm() must be awaited first!");
30726 const nativeResponseValue = wasm.TS_ChannelUsage_clone_ptr(arg);
30727 return nativeResponseValue;
30729 // struct LDKChannelUsage ChannelUsage_clone(const struct LDKChannelUsage *NONNULL_PTR orig);
30731 export function ChannelUsage_clone(orig: number): number {
30732 if(!isWasmInitialized) {
30733 throw new Error("initializeWasm() must be awaited first!");
30735 const nativeResponseValue = wasm.TS_ChannelUsage_clone(orig);
30736 return nativeResponseValue;
30738 // void FixedPenaltyScorer_free(struct LDKFixedPenaltyScorer this_obj);
30740 export function FixedPenaltyScorer_free(this_obj: number): void {
30741 if(!isWasmInitialized) {
30742 throw new Error("initializeWasm() must be awaited first!");
30744 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_free(this_obj);
30745 // debug statements here
30747 // uintptr_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg);
30749 export function FixedPenaltyScorer_clone_ptr(arg: number): number {
30750 if(!isWasmInitialized) {
30751 throw new Error("initializeWasm() must be awaited first!");
30753 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone_ptr(arg);
30754 return nativeResponseValue;
30756 // struct LDKFixedPenaltyScorer FixedPenaltyScorer_clone(const struct LDKFixedPenaltyScorer *NONNULL_PTR orig);
30758 export function FixedPenaltyScorer_clone(orig: number): number {
30759 if(!isWasmInitialized) {
30760 throw new Error("initializeWasm() must be awaited first!");
30762 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_clone(orig);
30763 return nativeResponseValue;
30765 // MUST_USE_RES struct LDKFixedPenaltyScorer FixedPenaltyScorer_with_penalty(uint64_t penalty_msat);
30767 export function FixedPenaltyScorer_with_penalty(penalty_msat: bigint): number {
30768 if(!isWasmInitialized) {
30769 throw new Error("initializeWasm() must be awaited first!");
30771 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_with_penalty(penalty_msat);
30772 return nativeResponseValue;
30774 // struct LDKScore FixedPenaltyScorer_as_Score(const struct LDKFixedPenaltyScorer *NONNULL_PTR this_arg);
30776 export function FixedPenaltyScorer_as_Score(this_arg: number): number {
30777 if(!isWasmInitialized) {
30778 throw new Error("initializeWasm() must be awaited first!");
30780 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_as_Score(this_arg);
30781 return nativeResponseValue;
30783 // struct LDKCVec_u8Z FixedPenaltyScorer_write(const struct LDKFixedPenaltyScorer *NONNULL_PTR obj);
30785 export function FixedPenaltyScorer_write(obj: number): number {
30786 if(!isWasmInitialized) {
30787 throw new Error("initializeWasm() must be awaited first!");
30789 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_write(obj);
30790 return nativeResponseValue;
30792 // struct LDKCResult_FixedPenaltyScorerDecodeErrorZ FixedPenaltyScorer_read(struct LDKu8slice ser, uint64_t arg);
30794 export function FixedPenaltyScorer_read(ser: number, arg: bigint): number {
30795 if(!isWasmInitialized) {
30796 throw new Error("initializeWasm() must be awaited first!");
30798 const nativeResponseValue = wasm.TS_FixedPenaltyScorer_read(ser, arg);
30799 return nativeResponseValue;
30801 // void ProbabilisticScorer_free(struct LDKProbabilisticScorer this_obj);
30803 export function ProbabilisticScorer_free(this_obj: number): void {
30804 if(!isWasmInitialized) {
30805 throw new Error("initializeWasm() must be awaited first!");
30807 const nativeResponseValue = wasm.TS_ProbabilisticScorer_free(this_obj);
30808 // debug statements here
30810 // void ProbabilisticScoringParameters_free(struct LDKProbabilisticScoringParameters this_obj);
30812 export function ProbabilisticScoringParameters_free(this_obj: number): void {
30813 if(!isWasmInitialized) {
30814 throw new Error("initializeWasm() must be awaited first!");
30816 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_free(this_obj);
30817 // debug statements here
30819 // uint64_t ProbabilisticScoringParameters_get_base_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30821 export function ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr: number): bigint {
30822 if(!isWasmInitialized) {
30823 throw new Error("initializeWasm() must be awaited first!");
30825 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_base_penalty_msat(this_ptr);
30826 return nativeResponseValue;
30828 // void ProbabilisticScoringParameters_set_base_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30830 export function ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr: number, val: bigint): void {
30831 if(!isWasmInitialized) {
30832 throw new Error("initializeWasm() must be awaited first!");
30834 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_base_penalty_msat(this_ptr, val);
30835 // debug statements here
30837 // uint64_t ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30839 export function ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr: number): bigint {
30840 if(!isWasmInitialized) {
30841 throw new Error("initializeWasm() must be awaited first!");
30843 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(this_ptr);
30844 return nativeResponseValue;
30846 // void ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30848 export function ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
30849 if(!isWasmInitialized) {
30850 throw new Error("initializeWasm() must be awaited first!");
30852 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(this_ptr, val);
30853 // debug statements here
30855 // uint64_t ProbabilisticScoringParameters_get_liquidity_offset_half_life(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30857 export function ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr: number): bigint {
30858 if(!isWasmInitialized) {
30859 throw new Error("initializeWasm() must be awaited first!");
30861 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(this_ptr);
30862 return nativeResponseValue;
30864 // void ProbabilisticScoringParameters_set_liquidity_offset_half_life(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30866 export function ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr: number, val: bigint): void {
30867 if(!isWasmInitialized) {
30868 throw new Error("initializeWasm() must be awaited first!");
30870 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(this_ptr, val);
30871 // debug statements here
30873 // uint64_t ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30875 export function ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(this_ptr: number): bigint {
30876 if(!isWasmInitialized) {
30877 throw new Error("initializeWasm() must be awaited first!");
30879 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_amount_penalty_multiplier_msat(this_ptr);
30880 return nativeResponseValue;
30882 // void ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30884 export function ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(this_ptr: number, val: bigint): void {
30885 if(!isWasmInitialized) {
30886 throw new Error("initializeWasm() must be awaited first!");
30888 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_amount_penalty_multiplier_msat(this_ptr, val);
30889 // debug statements here
30891 // uint64_t ProbabilisticScoringParameters_get_anti_probing_penalty_msat(const struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr);
30893 export function ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr: number): bigint {
30894 if(!isWasmInitialized) {
30895 throw new Error("initializeWasm() must be awaited first!");
30897 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(this_ptr);
30898 return nativeResponseValue;
30900 // void ProbabilisticScoringParameters_set_anti_probing_penalty_msat(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_ptr, uint64_t val);
30902 export function ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr: number, val: bigint): void {
30903 if(!isWasmInitialized) {
30904 throw new Error("initializeWasm() must be awaited first!");
30906 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(this_ptr, val);
30907 // debug statements here
30909 // uintptr_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg);
30911 export function ProbabilisticScoringParameters_clone_ptr(arg: number): number {
30912 if(!isWasmInitialized) {
30913 throw new Error("initializeWasm() must be awaited first!");
30915 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone_ptr(arg);
30916 return nativeResponseValue;
30918 // struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_clone(const struct LDKProbabilisticScoringParameters *NONNULL_PTR orig);
30920 export function ProbabilisticScoringParameters_clone(orig: number): number {
30921 if(!isWasmInitialized) {
30922 throw new Error("initializeWasm() must be awaited first!");
30924 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_clone(orig);
30925 return nativeResponseValue;
30927 // MUST_USE_RES struct LDKProbabilisticScorer ProbabilisticScorer_new(struct LDKProbabilisticScoringParameters params, const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
30929 export function ProbabilisticScorer_new(params: number, network_graph: number, logger: number): number {
30930 if(!isWasmInitialized) {
30931 throw new Error("initializeWasm() must be awaited first!");
30933 const nativeResponseValue = wasm.TS_ProbabilisticScorer_new(params, network_graph, logger);
30934 return nativeResponseValue;
30936 // void ProbabilisticScorer_debug_log_liquidity_stats(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
30938 export function ProbabilisticScorer_debug_log_liquidity_stats(this_arg: number): void {
30939 if(!isWasmInitialized) {
30940 throw new Error("initializeWasm() must be awaited first!");
30942 const nativeResponseValue = wasm.TS_ProbabilisticScorer_debug_log_liquidity_stats(this_arg);
30943 // debug statements here
30945 // MUST_USE_RES struct LDKCOption_C2Tuple_u64u64ZZ ProbabilisticScorer_estimated_channel_liquidity_range(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg, uint64_t scid, const struct LDKNodeId *NONNULL_PTR target);
30947 export function ProbabilisticScorer_estimated_channel_liquidity_range(this_arg: number, scid: bigint, target: number): number {
30948 if(!isWasmInitialized) {
30949 throw new Error("initializeWasm() must be awaited first!");
30951 const nativeResponseValue = wasm.TS_ProbabilisticScorer_estimated_channel_liquidity_range(this_arg, scid, target);
30952 return nativeResponseValue;
30954 // void ProbabilisticScorer_add_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
30956 export function ProbabilisticScorer_add_banned(this_arg: number, node_id: number): void {
30957 if(!isWasmInitialized) {
30958 throw new Error("initializeWasm() must be awaited first!");
30960 const nativeResponseValue = wasm.TS_ProbabilisticScorer_add_banned(this_arg, node_id);
30961 // debug statements here
30963 // void ProbabilisticScorer_remove_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg, const struct LDKNodeId *NONNULL_PTR node_id);
30965 export function ProbabilisticScorer_remove_banned(this_arg: number, node_id: number): void {
30966 if(!isWasmInitialized) {
30967 throw new Error("initializeWasm() must be awaited first!");
30969 const nativeResponseValue = wasm.TS_ProbabilisticScorer_remove_banned(this_arg, node_id);
30970 // debug statements here
30972 // void ProbabilisticScorer_clear_banned(struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
30974 export function ProbabilisticScorer_clear_banned(this_arg: number): void {
30975 if(!isWasmInitialized) {
30976 throw new Error("initializeWasm() must be awaited first!");
30978 const nativeResponseValue = wasm.TS_ProbabilisticScorer_clear_banned(this_arg);
30979 // debug statements here
30981 // void ProbabilisticScoringParameters_add_banned_from_list(struct LDKProbabilisticScoringParameters *NONNULL_PTR this_arg, struct LDKCVec_NodeIdZ node_ids);
30983 export function ProbabilisticScoringParameters_add_banned_from_list(this_arg: number, node_ids: number): void {
30984 if(!isWasmInitialized) {
30985 throw new Error("initializeWasm() must be awaited first!");
30987 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_add_banned_from_list(this_arg, node_ids);
30988 // debug statements here
30990 // MUST_USE_RES struct LDKProbabilisticScoringParameters ProbabilisticScoringParameters_default(void);
30992 export function ProbabilisticScoringParameters_default(): number {
30993 if(!isWasmInitialized) {
30994 throw new Error("initializeWasm() must be awaited first!");
30996 const nativeResponseValue = wasm.TS_ProbabilisticScoringParameters_default();
30997 return nativeResponseValue;
30999 // struct LDKScore ProbabilisticScorer_as_Score(const struct LDKProbabilisticScorer *NONNULL_PTR this_arg);
31001 export function ProbabilisticScorer_as_Score(this_arg: number): number {
31002 if(!isWasmInitialized) {
31003 throw new Error("initializeWasm() must be awaited first!");
31005 const nativeResponseValue = wasm.TS_ProbabilisticScorer_as_Score(this_arg);
31006 return nativeResponseValue;
31008 // struct LDKCVec_u8Z ProbabilisticScorer_write(const struct LDKProbabilisticScorer *NONNULL_PTR obj);
31010 export function ProbabilisticScorer_write(obj: number): number {
31011 if(!isWasmInitialized) {
31012 throw new Error("initializeWasm() must be awaited first!");
31014 const nativeResponseValue = wasm.TS_ProbabilisticScorer_write(obj);
31015 return nativeResponseValue;
31017 // struct LDKCResult_ProbabilisticScorerDecodeErrorZ ProbabilisticScorer_read(struct LDKu8slice ser, struct LDKProbabilisticScoringParameters arg_a, const struct LDKNetworkGraph *NONNULL_PTR arg_b, struct LDKLogger arg_c);
31019 export function ProbabilisticScorer_read(ser: number, arg_a: number, arg_b: number, arg_c: number): number {
31020 if(!isWasmInitialized) {
31021 throw new Error("initializeWasm() must be awaited first!");
31023 const nativeResponseValue = wasm.TS_ProbabilisticScorer_read(ser, arg_a, arg_b, arg_c);
31024 return nativeResponseValue;
31026 // void ParseError_free(struct LDKParseError this_ptr);
31028 export function ParseError_free(this_ptr: number): void {
31029 if(!isWasmInitialized) {
31030 throw new Error("initializeWasm() must be awaited first!");
31032 const nativeResponseValue = wasm.TS_ParseError_free(this_ptr);
31033 // debug statements here
31035 // uintptr_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg);
31037 export function ParseError_clone_ptr(arg: number): number {
31038 if(!isWasmInitialized) {
31039 throw new Error("initializeWasm() must be awaited first!");
31041 const nativeResponseValue = wasm.TS_ParseError_clone_ptr(arg);
31042 return nativeResponseValue;
31044 // struct LDKParseError ParseError_clone(const struct LDKParseError *NONNULL_PTR orig);
31046 export function ParseError_clone(orig: number): number {
31047 if(!isWasmInitialized) {
31048 throw new Error("initializeWasm() must be awaited first!");
31050 const nativeResponseValue = wasm.TS_ParseError_clone(orig);
31051 return nativeResponseValue;
31053 // struct LDKParseError ParseError_bech32_error(struct LDKBech32Error a);
31055 export function ParseError_bech32_error(a: number): number {
31056 if(!isWasmInitialized) {
31057 throw new Error("initializeWasm() must be awaited first!");
31059 const nativeResponseValue = wasm.TS_ParseError_bech32_error(a);
31060 return nativeResponseValue;
31062 // struct LDKParseError ParseError_parse_amount_error(struct LDKError a);
31064 export function ParseError_parse_amount_error(a: number): number {
31065 if(!isWasmInitialized) {
31066 throw new Error("initializeWasm() must be awaited first!");
31068 const nativeResponseValue = wasm.TS_ParseError_parse_amount_error(a);
31069 return nativeResponseValue;
31071 // struct LDKParseError ParseError_malformed_signature(enum LDKSecp256k1Error a);
31073 export function ParseError_malformed_signature(a: Secp256k1Error): number {
31074 if(!isWasmInitialized) {
31075 throw new Error("initializeWasm() must be awaited first!");
31077 const nativeResponseValue = wasm.TS_ParseError_malformed_signature(a);
31078 return nativeResponseValue;
31080 // struct LDKParseError ParseError_bad_prefix(void);
31082 export function ParseError_bad_prefix(): number {
31083 if(!isWasmInitialized) {
31084 throw new Error("initializeWasm() must be awaited first!");
31086 const nativeResponseValue = wasm.TS_ParseError_bad_prefix();
31087 return nativeResponseValue;
31089 // struct LDKParseError ParseError_unknown_currency(void);
31091 export function ParseError_unknown_currency(): number {
31092 if(!isWasmInitialized) {
31093 throw new Error("initializeWasm() must be awaited first!");
31095 const nativeResponseValue = wasm.TS_ParseError_unknown_currency();
31096 return nativeResponseValue;
31098 // struct LDKParseError ParseError_unknown_si_prefix(void);
31100 export function ParseError_unknown_si_prefix(): number {
31101 if(!isWasmInitialized) {
31102 throw new Error("initializeWasm() must be awaited first!");
31104 const nativeResponseValue = wasm.TS_ParseError_unknown_si_prefix();
31105 return nativeResponseValue;
31107 // struct LDKParseError ParseError_malformed_hrp(void);
31109 export function ParseError_malformed_hrp(): number {
31110 if(!isWasmInitialized) {
31111 throw new Error("initializeWasm() must be awaited first!");
31113 const nativeResponseValue = wasm.TS_ParseError_malformed_hrp();
31114 return nativeResponseValue;
31116 // struct LDKParseError ParseError_too_short_data_part(void);
31118 export function ParseError_too_short_data_part(): number {
31119 if(!isWasmInitialized) {
31120 throw new Error("initializeWasm() must be awaited first!");
31122 const nativeResponseValue = wasm.TS_ParseError_too_short_data_part();
31123 return nativeResponseValue;
31125 // struct LDKParseError ParseError_unexpected_end_of_tagged_fields(void);
31127 export function ParseError_unexpected_end_of_tagged_fields(): number {
31128 if(!isWasmInitialized) {
31129 throw new Error("initializeWasm() must be awaited first!");
31131 const nativeResponseValue = wasm.TS_ParseError_unexpected_end_of_tagged_fields();
31132 return nativeResponseValue;
31134 // struct LDKParseError ParseError_description_decode_error(struct LDKError a);
31136 export function ParseError_description_decode_error(a: number): number {
31137 if(!isWasmInitialized) {
31138 throw new Error("initializeWasm() must be awaited first!");
31140 const nativeResponseValue = wasm.TS_ParseError_description_decode_error(a);
31141 return nativeResponseValue;
31143 // struct LDKParseError ParseError_padding_error(void);
31145 export function ParseError_padding_error(): number {
31146 if(!isWasmInitialized) {
31147 throw new Error("initializeWasm() must be awaited first!");
31149 const nativeResponseValue = wasm.TS_ParseError_padding_error();
31150 return nativeResponseValue;
31152 // struct LDKParseError ParseError_integer_overflow_error(void);
31154 export function ParseError_integer_overflow_error(): number {
31155 if(!isWasmInitialized) {
31156 throw new Error("initializeWasm() must be awaited first!");
31158 const nativeResponseValue = wasm.TS_ParseError_integer_overflow_error();
31159 return nativeResponseValue;
31161 // struct LDKParseError ParseError_invalid_seg_wit_program_length(void);
31163 export function ParseError_invalid_seg_wit_program_length(): number {
31164 if(!isWasmInitialized) {
31165 throw new Error("initializeWasm() must be awaited first!");
31167 const nativeResponseValue = wasm.TS_ParseError_invalid_seg_wit_program_length();
31168 return nativeResponseValue;
31170 // struct LDKParseError ParseError_invalid_pub_key_hash_length(void);
31172 export function ParseError_invalid_pub_key_hash_length(): number {
31173 if(!isWasmInitialized) {
31174 throw new Error("initializeWasm() must be awaited first!");
31176 const nativeResponseValue = wasm.TS_ParseError_invalid_pub_key_hash_length();
31177 return nativeResponseValue;
31179 // struct LDKParseError ParseError_invalid_script_hash_length(void);
31181 export function ParseError_invalid_script_hash_length(): number {
31182 if(!isWasmInitialized) {
31183 throw new Error("initializeWasm() must be awaited first!");
31185 const nativeResponseValue = wasm.TS_ParseError_invalid_script_hash_length();
31186 return nativeResponseValue;
31188 // struct LDKParseError ParseError_invalid_recovery_id(void);
31190 export function ParseError_invalid_recovery_id(): number {
31191 if(!isWasmInitialized) {
31192 throw new Error("initializeWasm() must be awaited first!");
31194 const nativeResponseValue = wasm.TS_ParseError_invalid_recovery_id();
31195 return nativeResponseValue;
31197 // struct LDKParseError ParseError_invalid_slice_length(struct LDKStr a);
31199 export function ParseError_invalid_slice_length(a: number): number {
31200 if(!isWasmInitialized) {
31201 throw new Error("initializeWasm() must be awaited first!");
31203 const nativeResponseValue = wasm.TS_ParseError_invalid_slice_length(a);
31204 return nativeResponseValue;
31206 // struct LDKParseError ParseError_skip(void);
31208 export function ParseError_skip(): number {
31209 if(!isWasmInitialized) {
31210 throw new Error("initializeWasm() must be awaited first!");
31212 const nativeResponseValue = wasm.TS_ParseError_skip();
31213 return nativeResponseValue;
31215 // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
31217 export function ParseOrSemanticError_free(this_ptr: number): void {
31218 if(!isWasmInitialized) {
31219 throw new Error("initializeWasm() must be awaited first!");
31221 const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
31222 // debug statements here
31224 // uintptr_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
31226 export function ParseOrSemanticError_clone_ptr(arg: number): number {
31227 if(!isWasmInitialized) {
31228 throw new Error("initializeWasm() must be awaited first!");
31230 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
31231 return nativeResponseValue;
31233 // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
31235 export function ParseOrSemanticError_clone(orig: number): number {
31236 if(!isWasmInitialized) {
31237 throw new Error("initializeWasm() must be awaited first!");
31239 const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
31240 return nativeResponseValue;
31242 // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKParseError a);
31244 export function ParseOrSemanticError_parse_error(a: number): number {
31245 if(!isWasmInitialized) {
31246 throw new Error("initializeWasm() must be awaited first!");
31248 const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
31249 return nativeResponseValue;
31251 // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKSemanticError a);
31253 export function ParseOrSemanticError_semantic_error(a: SemanticError): number {
31254 if(!isWasmInitialized) {
31255 throw new Error("initializeWasm() must be awaited first!");
31257 const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
31258 return nativeResponseValue;
31260 // void Invoice_free(struct LDKInvoice this_obj);
31262 export function Invoice_free(this_obj: number): void {
31263 if(!isWasmInitialized) {
31264 throw new Error("initializeWasm() must be awaited first!");
31266 const nativeResponseValue = wasm.TS_Invoice_free(this_obj);
31267 // debug statements here
31269 // bool Invoice_eq(const struct LDKInvoice *NONNULL_PTR a, const struct LDKInvoice *NONNULL_PTR b);
31271 export function Invoice_eq(a: number, b: number): boolean {
31272 if(!isWasmInitialized) {
31273 throw new Error("initializeWasm() must be awaited first!");
31275 const nativeResponseValue = wasm.TS_Invoice_eq(a, b);
31276 return nativeResponseValue;
31278 // uintptr_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg);
31280 export function Invoice_clone_ptr(arg: number): number {
31281 if(!isWasmInitialized) {
31282 throw new Error("initializeWasm() must be awaited first!");
31284 const nativeResponseValue = wasm.TS_Invoice_clone_ptr(arg);
31285 return nativeResponseValue;
31287 // struct LDKInvoice Invoice_clone(const struct LDKInvoice *NONNULL_PTR orig);
31289 export function Invoice_clone(orig: number): number {
31290 if(!isWasmInitialized) {
31291 throw new Error("initializeWasm() must be awaited first!");
31293 const nativeResponseValue = wasm.TS_Invoice_clone(orig);
31294 return nativeResponseValue;
31296 // void SignedRawInvoice_free(struct LDKSignedRawInvoice this_obj);
31298 export function SignedRawInvoice_free(this_obj: number): void {
31299 if(!isWasmInitialized) {
31300 throw new Error("initializeWasm() must be awaited first!");
31302 const nativeResponseValue = wasm.TS_SignedRawInvoice_free(this_obj);
31303 // debug statements here
31305 // bool SignedRawInvoice_eq(const struct LDKSignedRawInvoice *NONNULL_PTR a, const struct LDKSignedRawInvoice *NONNULL_PTR b);
31307 export function SignedRawInvoice_eq(a: number, b: number): boolean {
31308 if(!isWasmInitialized) {
31309 throw new Error("initializeWasm() must be awaited first!");
31311 const nativeResponseValue = wasm.TS_SignedRawInvoice_eq(a, b);
31312 return nativeResponseValue;
31314 // uintptr_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg);
31316 export function SignedRawInvoice_clone_ptr(arg: number): number {
31317 if(!isWasmInitialized) {
31318 throw new Error("initializeWasm() must be awaited first!");
31320 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone_ptr(arg);
31321 return nativeResponseValue;
31323 // struct LDKSignedRawInvoice SignedRawInvoice_clone(const struct LDKSignedRawInvoice *NONNULL_PTR orig);
31325 export function SignedRawInvoice_clone(orig: number): number {
31326 if(!isWasmInitialized) {
31327 throw new Error("initializeWasm() must be awaited first!");
31329 const nativeResponseValue = wasm.TS_SignedRawInvoice_clone(orig);
31330 return nativeResponseValue;
31332 // void RawInvoice_free(struct LDKRawInvoice this_obj);
31334 export function RawInvoice_free(this_obj: number): void {
31335 if(!isWasmInitialized) {
31336 throw new Error("initializeWasm() must be awaited first!");
31338 const nativeResponseValue = wasm.TS_RawInvoice_free(this_obj);
31339 // debug statements here
31341 // struct LDKRawDataPart RawInvoice_get_data(const struct LDKRawInvoice *NONNULL_PTR this_ptr);
31343 export function RawInvoice_get_data(this_ptr: number): number {
31344 if(!isWasmInitialized) {
31345 throw new Error("initializeWasm() must be awaited first!");
31347 const nativeResponseValue = wasm.TS_RawInvoice_get_data(this_ptr);
31348 return nativeResponseValue;
31350 // void RawInvoice_set_data(struct LDKRawInvoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
31352 export function RawInvoice_set_data(this_ptr: number, val: number): void {
31353 if(!isWasmInitialized) {
31354 throw new Error("initializeWasm() must be awaited first!");
31356 const nativeResponseValue = wasm.TS_RawInvoice_set_data(this_ptr, val);
31357 // debug statements here
31359 // bool RawInvoice_eq(const struct LDKRawInvoice *NONNULL_PTR a, const struct LDKRawInvoice *NONNULL_PTR b);
31361 export function RawInvoice_eq(a: number, b: number): boolean {
31362 if(!isWasmInitialized) {
31363 throw new Error("initializeWasm() must be awaited first!");
31365 const nativeResponseValue = wasm.TS_RawInvoice_eq(a, b);
31366 return nativeResponseValue;
31368 // uintptr_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg);
31370 export function RawInvoice_clone_ptr(arg: number): number {
31371 if(!isWasmInitialized) {
31372 throw new Error("initializeWasm() must be awaited first!");
31374 const nativeResponseValue = wasm.TS_RawInvoice_clone_ptr(arg);
31375 return nativeResponseValue;
31377 // struct LDKRawInvoice RawInvoice_clone(const struct LDKRawInvoice *NONNULL_PTR orig);
31379 export function RawInvoice_clone(orig: number): number {
31380 if(!isWasmInitialized) {
31381 throw new Error("initializeWasm() must be awaited first!");
31383 const nativeResponseValue = wasm.TS_RawInvoice_clone(orig);
31384 return nativeResponseValue;
31386 // void RawDataPart_free(struct LDKRawDataPart this_obj);
31388 export function RawDataPart_free(this_obj: number): void {
31389 if(!isWasmInitialized) {
31390 throw new Error("initializeWasm() must be awaited first!");
31392 const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
31393 // debug statements here
31395 // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
31397 export function RawDataPart_get_timestamp(this_ptr: number): number {
31398 if(!isWasmInitialized) {
31399 throw new Error("initializeWasm() must be awaited first!");
31401 const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
31402 return nativeResponseValue;
31404 // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
31406 export function RawDataPart_set_timestamp(this_ptr: number, val: number): void {
31407 if(!isWasmInitialized) {
31408 throw new Error("initializeWasm() must be awaited first!");
31410 const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
31411 // debug statements here
31413 // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
31415 export function RawDataPart_eq(a: number, b: number): boolean {
31416 if(!isWasmInitialized) {
31417 throw new Error("initializeWasm() must be awaited first!");
31419 const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
31420 return nativeResponseValue;
31422 // uintptr_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
31424 export function RawDataPart_clone_ptr(arg: number): number {
31425 if(!isWasmInitialized) {
31426 throw new Error("initializeWasm() must be awaited first!");
31428 const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
31429 return nativeResponseValue;
31431 // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
31433 export function RawDataPart_clone(orig: number): number {
31434 if(!isWasmInitialized) {
31435 throw new Error("initializeWasm() must be awaited first!");
31437 const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
31438 return nativeResponseValue;
31440 // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
31442 export function PositiveTimestamp_free(this_obj: number): void {
31443 if(!isWasmInitialized) {
31444 throw new Error("initializeWasm() must be awaited first!");
31446 const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
31447 // debug statements here
31449 // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
31451 export function PositiveTimestamp_eq(a: number, b: number): boolean {
31452 if(!isWasmInitialized) {
31453 throw new Error("initializeWasm() must be awaited first!");
31455 const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
31456 return nativeResponseValue;
31458 // uintptr_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
31460 export function PositiveTimestamp_clone_ptr(arg: number): number {
31461 if(!isWasmInitialized) {
31462 throw new Error("initializeWasm() must be awaited first!");
31464 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
31465 return nativeResponseValue;
31467 // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
31469 export function PositiveTimestamp_clone(orig: number): number {
31470 if(!isWasmInitialized) {
31471 throw new Error("initializeWasm() must be awaited first!");
31473 const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
31474 return nativeResponseValue;
31476 // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
31478 export function SiPrefix_clone(orig: number): SiPrefix {
31479 if(!isWasmInitialized) {
31480 throw new Error("initializeWasm() must be awaited first!");
31482 const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
31483 return nativeResponseValue;
31485 // enum LDKSiPrefix SiPrefix_milli(void);
31487 export function SiPrefix_milli(): SiPrefix {
31488 if(!isWasmInitialized) {
31489 throw new Error("initializeWasm() must be awaited first!");
31491 const nativeResponseValue = wasm.TS_SiPrefix_milli();
31492 return nativeResponseValue;
31494 // enum LDKSiPrefix SiPrefix_micro(void);
31496 export function SiPrefix_micro(): SiPrefix {
31497 if(!isWasmInitialized) {
31498 throw new Error("initializeWasm() must be awaited first!");
31500 const nativeResponseValue = wasm.TS_SiPrefix_micro();
31501 return nativeResponseValue;
31503 // enum LDKSiPrefix SiPrefix_nano(void);
31505 export function SiPrefix_nano(): SiPrefix {
31506 if(!isWasmInitialized) {
31507 throw new Error("initializeWasm() must be awaited first!");
31509 const nativeResponseValue = wasm.TS_SiPrefix_nano();
31510 return nativeResponseValue;
31512 // enum LDKSiPrefix SiPrefix_pico(void);
31514 export function SiPrefix_pico(): SiPrefix {
31515 if(!isWasmInitialized) {
31516 throw new Error("initializeWasm() must be awaited first!");
31518 const nativeResponseValue = wasm.TS_SiPrefix_pico();
31519 return nativeResponseValue;
31521 // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
31523 export function SiPrefix_eq(a: number, b: number): boolean {
31524 if(!isWasmInitialized) {
31525 throw new Error("initializeWasm() must be awaited first!");
31527 const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
31528 return nativeResponseValue;
31530 // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
31532 export function SiPrefix_multiplier(this_arg: number): bigint {
31533 if(!isWasmInitialized) {
31534 throw new Error("initializeWasm() must be awaited first!");
31536 const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
31537 return nativeResponseValue;
31539 // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
31541 export function Currency_clone(orig: number): Currency {
31542 if(!isWasmInitialized) {
31543 throw new Error("initializeWasm() must be awaited first!");
31545 const nativeResponseValue = wasm.TS_Currency_clone(orig);
31546 return nativeResponseValue;
31548 // enum LDKCurrency Currency_bitcoin(void);
31550 export function Currency_bitcoin(): Currency {
31551 if(!isWasmInitialized) {
31552 throw new Error("initializeWasm() must be awaited first!");
31554 const nativeResponseValue = wasm.TS_Currency_bitcoin();
31555 return nativeResponseValue;
31557 // enum LDKCurrency Currency_bitcoin_testnet(void);
31559 export function Currency_bitcoin_testnet(): Currency {
31560 if(!isWasmInitialized) {
31561 throw new Error("initializeWasm() must be awaited first!");
31563 const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
31564 return nativeResponseValue;
31566 // enum LDKCurrency Currency_regtest(void);
31568 export function Currency_regtest(): Currency {
31569 if(!isWasmInitialized) {
31570 throw new Error("initializeWasm() must be awaited first!");
31572 const nativeResponseValue = wasm.TS_Currency_regtest();
31573 return nativeResponseValue;
31575 // enum LDKCurrency Currency_simnet(void);
31577 export function Currency_simnet(): Currency {
31578 if(!isWasmInitialized) {
31579 throw new Error("initializeWasm() must be awaited first!");
31581 const nativeResponseValue = wasm.TS_Currency_simnet();
31582 return nativeResponseValue;
31584 // enum LDKCurrency Currency_signet(void);
31586 export function Currency_signet(): Currency {
31587 if(!isWasmInitialized) {
31588 throw new Error("initializeWasm() must be awaited first!");
31590 const nativeResponseValue = wasm.TS_Currency_signet();
31591 return nativeResponseValue;
31593 // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
31595 export function Currency_hash(o: number): bigint {
31596 if(!isWasmInitialized) {
31597 throw new Error("initializeWasm() must be awaited first!");
31599 const nativeResponseValue = wasm.TS_Currency_hash(o);
31600 return nativeResponseValue;
31602 // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
31604 export function Currency_eq(a: number, b: number): boolean {
31605 if(!isWasmInitialized) {
31606 throw new Error("initializeWasm() must be awaited first!");
31608 const nativeResponseValue = wasm.TS_Currency_eq(a, b);
31609 return nativeResponseValue;
31611 // void Sha256_free(struct LDKSha256 this_obj);
31613 export function Sha256_free(this_obj: number): void {
31614 if(!isWasmInitialized) {
31615 throw new Error("initializeWasm() must be awaited first!");
31617 const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
31618 // debug statements here
31620 // uintptr_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
31622 export function Sha256_clone_ptr(arg: number): number {
31623 if(!isWasmInitialized) {
31624 throw new Error("initializeWasm() must be awaited first!");
31626 const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
31627 return nativeResponseValue;
31629 // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
31631 export function Sha256_clone(orig: number): number {
31632 if(!isWasmInitialized) {
31633 throw new Error("initializeWasm() must be awaited first!");
31635 const nativeResponseValue = wasm.TS_Sha256_clone(orig);
31636 return nativeResponseValue;
31638 // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
31640 export function Sha256_hash(o: number): bigint {
31641 if(!isWasmInitialized) {
31642 throw new Error("initializeWasm() must be awaited first!");
31644 const nativeResponseValue = wasm.TS_Sha256_hash(o);
31645 return nativeResponseValue;
31647 // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
31649 export function Sha256_eq(a: number, b: number): boolean {
31650 if(!isWasmInitialized) {
31651 throw new Error("initializeWasm() must be awaited first!");
31653 const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
31654 return nativeResponseValue;
31656 // void Description_free(struct LDKDescription this_obj);
31658 export function Description_free(this_obj: number): void {
31659 if(!isWasmInitialized) {
31660 throw new Error("initializeWasm() must be awaited first!");
31662 const nativeResponseValue = wasm.TS_Description_free(this_obj);
31663 // debug statements here
31665 // uintptr_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
31667 export function Description_clone_ptr(arg: number): number {
31668 if(!isWasmInitialized) {
31669 throw new Error("initializeWasm() must be awaited first!");
31671 const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
31672 return nativeResponseValue;
31674 // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
31676 export function Description_clone(orig: number): number {
31677 if(!isWasmInitialized) {
31678 throw new Error("initializeWasm() must be awaited first!");
31680 const nativeResponseValue = wasm.TS_Description_clone(orig);
31681 return nativeResponseValue;
31683 // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
31685 export function Description_hash(o: number): bigint {
31686 if(!isWasmInitialized) {
31687 throw new Error("initializeWasm() must be awaited first!");
31689 const nativeResponseValue = wasm.TS_Description_hash(o);
31690 return nativeResponseValue;
31692 // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
31694 export function Description_eq(a: number, b: number): boolean {
31695 if(!isWasmInitialized) {
31696 throw new Error("initializeWasm() must be awaited first!");
31698 const nativeResponseValue = wasm.TS_Description_eq(a, b);
31699 return nativeResponseValue;
31701 // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
31703 export function PayeePubKey_free(this_obj: number): void {
31704 if(!isWasmInitialized) {
31705 throw new Error("initializeWasm() must be awaited first!");
31707 const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
31708 // debug statements here
31710 // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
31712 export function PayeePubKey_get_a(this_ptr: number): number {
31713 if(!isWasmInitialized) {
31714 throw new Error("initializeWasm() must be awaited first!");
31716 const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
31717 return nativeResponseValue;
31719 // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
31721 export function PayeePubKey_set_a(this_ptr: number, val: number): void {
31722 if(!isWasmInitialized) {
31723 throw new Error("initializeWasm() must be awaited first!");
31725 const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
31726 // debug statements here
31728 // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
31730 export function PayeePubKey_new(a_arg: number): number {
31731 if(!isWasmInitialized) {
31732 throw new Error("initializeWasm() must be awaited first!");
31734 const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
31735 return nativeResponseValue;
31737 // uintptr_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
31739 export function PayeePubKey_clone_ptr(arg: number): number {
31740 if(!isWasmInitialized) {
31741 throw new Error("initializeWasm() must be awaited first!");
31743 const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
31744 return nativeResponseValue;
31746 // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
31748 export function PayeePubKey_clone(orig: number): number {
31749 if(!isWasmInitialized) {
31750 throw new Error("initializeWasm() must be awaited first!");
31752 const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
31753 return nativeResponseValue;
31755 // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
31757 export function PayeePubKey_hash(o: number): bigint {
31758 if(!isWasmInitialized) {
31759 throw new Error("initializeWasm() must be awaited first!");
31761 const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
31762 return nativeResponseValue;
31764 // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
31766 export function PayeePubKey_eq(a: number, b: number): boolean {
31767 if(!isWasmInitialized) {
31768 throw new Error("initializeWasm() must be awaited first!");
31770 const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
31771 return nativeResponseValue;
31773 // void ExpiryTime_free(struct LDKExpiryTime this_obj);
31775 export function ExpiryTime_free(this_obj: number): void {
31776 if(!isWasmInitialized) {
31777 throw new Error("initializeWasm() must be awaited first!");
31779 const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
31780 // debug statements here
31782 // uintptr_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
31784 export function ExpiryTime_clone_ptr(arg: number): number {
31785 if(!isWasmInitialized) {
31786 throw new Error("initializeWasm() must be awaited first!");
31788 const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
31789 return nativeResponseValue;
31791 // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
31793 export function ExpiryTime_clone(orig: number): number {
31794 if(!isWasmInitialized) {
31795 throw new Error("initializeWasm() must be awaited first!");
31797 const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
31798 return nativeResponseValue;
31800 // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
31802 export function ExpiryTime_hash(o: number): bigint {
31803 if(!isWasmInitialized) {
31804 throw new Error("initializeWasm() must be awaited first!");
31806 const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
31807 return nativeResponseValue;
31809 // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
31811 export function ExpiryTime_eq(a: number, b: number): boolean {
31812 if(!isWasmInitialized) {
31813 throw new Error("initializeWasm() must be awaited first!");
31815 const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
31816 return nativeResponseValue;
31818 // void MinFinalCltvExpiry_free(struct LDKMinFinalCltvExpiry this_obj);
31820 export function MinFinalCltvExpiry_free(this_obj: number): void {
31821 if(!isWasmInitialized) {
31822 throw new Error("initializeWasm() must be awaited first!");
31824 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_free(this_obj);
31825 // debug statements here
31827 // uint64_t MinFinalCltvExpiry_get_a(const struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr);
31829 export function MinFinalCltvExpiry_get_a(this_ptr: number): bigint {
31830 if(!isWasmInitialized) {
31831 throw new Error("initializeWasm() must be awaited first!");
31833 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_get_a(this_ptr);
31834 return nativeResponseValue;
31836 // void MinFinalCltvExpiry_set_a(struct LDKMinFinalCltvExpiry *NONNULL_PTR this_ptr, uint64_t val);
31838 export function MinFinalCltvExpiry_set_a(this_ptr: number, val: bigint): void {
31839 if(!isWasmInitialized) {
31840 throw new Error("initializeWasm() must be awaited first!");
31842 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_set_a(this_ptr, val);
31843 // debug statements here
31845 // MUST_USE_RES struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_new(uint64_t a_arg);
31847 export function MinFinalCltvExpiry_new(a_arg: bigint): number {
31848 if(!isWasmInitialized) {
31849 throw new Error("initializeWasm() must be awaited first!");
31851 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_new(a_arg);
31852 return nativeResponseValue;
31854 // uintptr_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg);
31856 export function MinFinalCltvExpiry_clone_ptr(arg: number): number {
31857 if(!isWasmInitialized) {
31858 throw new Error("initializeWasm() must be awaited first!");
31860 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone_ptr(arg);
31861 return nativeResponseValue;
31863 // struct LDKMinFinalCltvExpiry MinFinalCltvExpiry_clone(const struct LDKMinFinalCltvExpiry *NONNULL_PTR orig);
31865 export function MinFinalCltvExpiry_clone(orig: number): number {
31866 if(!isWasmInitialized) {
31867 throw new Error("initializeWasm() must be awaited first!");
31869 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_clone(orig);
31870 return nativeResponseValue;
31872 // uint64_t MinFinalCltvExpiry_hash(const struct LDKMinFinalCltvExpiry *NONNULL_PTR o);
31874 export function MinFinalCltvExpiry_hash(o: number): bigint {
31875 if(!isWasmInitialized) {
31876 throw new Error("initializeWasm() must be awaited first!");
31878 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_hash(o);
31879 return nativeResponseValue;
31881 // bool MinFinalCltvExpiry_eq(const struct LDKMinFinalCltvExpiry *NONNULL_PTR a, const struct LDKMinFinalCltvExpiry *NONNULL_PTR b);
31883 export function MinFinalCltvExpiry_eq(a: number, b: number): boolean {
31884 if(!isWasmInitialized) {
31885 throw new Error("initializeWasm() must be awaited first!");
31887 const nativeResponseValue = wasm.TS_MinFinalCltvExpiry_eq(a, b);
31888 return nativeResponseValue;
31890 // void Fallback_free(struct LDKFallback this_ptr);
31892 export function Fallback_free(this_ptr: number): void {
31893 if(!isWasmInitialized) {
31894 throw new Error("initializeWasm() must be awaited first!");
31896 const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
31897 // debug statements here
31899 // uintptr_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
31901 export function Fallback_clone_ptr(arg: number): number {
31902 if(!isWasmInitialized) {
31903 throw new Error("initializeWasm() must be awaited first!");
31905 const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
31906 return nativeResponseValue;
31908 // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
31910 export function Fallback_clone(orig: number): number {
31911 if(!isWasmInitialized) {
31912 throw new Error("initializeWasm() must be awaited first!");
31914 const nativeResponseValue = wasm.TS_Fallback_clone(orig);
31915 return nativeResponseValue;
31917 // struct LDKFallback Fallback_seg_wit_program(struct LDKu5 version, struct LDKCVec_u8Z program);
31919 export function Fallback_seg_wit_program(version: number, program: number): number {
31920 if(!isWasmInitialized) {
31921 throw new Error("initializeWasm() must be awaited first!");
31923 const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
31924 return nativeResponseValue;
31926 // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
31928 export function Fallback_pub_key_hash(a: number): number {
31929 if(!isWasmInitialized) {
31930 throw new Error("initializeWasm() must be awaited first!");
31932 const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
31933 return nativeResponseValue;
31935 // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
31937 export function Fallback_script_hash(a: number): number {
31938 if(!isWasmInitialized) {
31939 throw new Error("initializeWasm() must be awaited first!");
31941 const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
31942 return nativeResponseValue;
31944 // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
31946 export function Fallback_hash(o: number): bigint {
31947 if(!isWasmInitialized) {
31948 throw new Error("initializeWasm() must be awaited first!");
31950 const nativeResponseValue = wasm.TS_Fallback_hash(o);
31951 return nativeResponseValue;
31953 // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
31955 export function Fallback_eq(a: number, b: number): boolean {
31956 if(!isWasmInitialized) {
31957 throw new Error("initializeWasm() must be awaited first!");
31959 const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
31960 return nativeResponseValue;
31962 // void InvoiceSignature_free(struct LDKInvoiceSignature this_obj);
31964 export function InvoiceSignature_free(this_obj: number): void {
31965 if(!isWasmInitialized) {
31966 throw new Error("initializeWasm() must be awaited first!");
31968 const nativeResponseValue = wasm.TS_InvoiceSignature_free(this_obj);
31969 // debug statements here
31971 // uintptr_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg);
31973 export function InvoiceSignature_clone_ptr(arg: number): number {
31974 if(!isWasmInitialized) {
31975 throw new Error("initializeWasm() must be awaited first!");
31977 const nativeResponseValue = wasm.TS_InvoiceSignature_clone_ptr(arg);
31978 return nativeResponseValue;
31980 // struct LDKInvoiceSignature InvoiceSignature_clone(const struct LDKInvoiceSignature *NONNULL_PTR orig);
31982 export function InvoiceSignature_clone(orig: number): number {
31983 if(!isWasmInitialized) {
31984 throw new Error("initializeWasm() must be awaited first!");
31986 const nativeResponseValue = wasm.TS_InvoiceSignature_clone(orig);
31987 return nativeResponseValue;
31989 // bool InvoiceSignature_eq(const struct LDKInvoiceSignature *NONNULL_PTR a, const struct LDKInvoiceSignature *NONNULL_PTR b);
31991 export function InvoiceSignature_eq(a: number, b: number): boolean {
31992 if(!isWasmInitialized) {
31993 throw new Error("initializeWasm() must be awaited first!");
31995 const nativeResponseValue = wasm.TS_InvoiceSignature_eq(a, b);
31996 return nativeResponseValue;
31998 // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
32000 export function PrivateRoute_free(this_obj: number): void {
32001 if(!isWasmInitialized) {
32002 throw new Error("initializeWasm() must be awaited first!");
32004 const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
32005 // debug statements here
32007 // uintptr_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
32009 export function PrivateRoute_clone_ptr(arg: number): number {
32010 if(!isWasmInitialized) {
32011 throw new Error("initializeWasm() must be awaited first!");
32013 const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
32014 return nativeResponseValue;
32016 // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
32018 export function PrivateRoute_clone(orig: number): number {
32019 if(!isWasmInitialized) {
32020 throw new Error("initializeWasm() must be awaited first!");
32022 const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
32023 return nativeResponseValue;
32025 // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
32027 export function PrivateRoute_hash(o: number): bigint {
32028 if(!isWasmInitialized) {
32029 throw new Error("initializeWasm() must be awaited first!");
32031 const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
32032 return nativeResponseValue;
32034 // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
32036 export function PrivateRoute_eq(a: number, b: number): boolean {
32037 if(!isWasmInitialized) {
32038 throw new Error("initializeWasm() must be awaited first!");
32040 const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
32041 return nativeResponseValue;
32043 // MUST_USE_RES struct LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ SignedRawInvoice_into_parts(struct LDKSignedRawInvoice this_arg);
32045 export function SignedRawInvoice_into_parts(this_arg: number): number {
32046 if(!isWasmInitialized) {
32047 throw new Error("initializeWasm() must be awaited first!");
32049 const nativeResponseValue = wasm.TS_SignedRawInvoice_into_parts(this_arg);
32050 return nativeResponseValue;
32052 // MUST_USE_RES struct LDKRawInvoice SignedRawInvoice_raw_invoice(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32054 export function SignedRawInvoice_raw_invoice(this_arg: number): number {
32055 if(!isWasmInitialized) {
32056 throw new Error("initializeWasm() must be awaited first!");
32058 const nativeResponseValue = wasm.TS_SignedRawInvoice_raw_invoice(this_arg);
32059 return nativeResponseValue;
32061 // MUST_USE_RES const uint8_t (*SignedRawInvoice_hash(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg))[32];
32063 export function SignedRawInvoice_hash(this_arg: number): number {
32064 if(!isWasmInitialized) {
32065 throw new Error("initializeWasm() must be awaited first!");
32067 const nativeResponseValue = wasm.TS_SignedRawInvoice_hash(this_arg);
32068 return nativeResponseValue;
32070 // MUST_USE_RES struct LDKInvoiceSignature SignedRawInvoice_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32072 export function SignedRawInvoice_signature(this_arg: number): number {
32073 if(!isWasmInitialized) {
32074 throw new Error("initializeWasm() must be awaited first!");
32076 const nativeResponseValue = wasm.TS_SignedRawInvoice_signature(this_arg);
32077 return nativeResponseValue;
32079 // MUST_USE_RES struct LDKCResult_PayeePubKeyErrorZ SignedRawInvoice_recover_payee_pub_key(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32081 export function SignedRawInvoice_recover_payee_pub_key(this_arg: number): number {
32082 if(!isWasmInitialized) {
32083 throw new Error("initializeWasm() must be awaited first!");
32085 const nativeResponseValue = wasm.TS_SignedRawInvoice_recover_payee_pub_key(this_arg);
32086 return nativeResponseValue;
32088 // MUST_USE_RES bool SignedRawInvoice_check_signature(const struct LDKSignedRawInvoice *NONNULL_PTR this_arg);
32090 export function SignedRawInvoice_check_signature(this_arg: number): boolean {
32091 if(!isWasmInitialized) {
32092 throw new Error("initializeWasm() must be awaited first!");
32094 const nativeResponseValue = wasm.TS_SignedRawInvoice_check_signature(this_arg);
32095 return nativeResponseValue;
32097 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32099 export function RawInvoice_hash(this_arg: number): number {
32100 if(!isWasmInitialized) {
32101 throw new Error("initializeWasm() must be awaited first!");
32103 const nativeResponseValue = wasm.TS_RawInvoice_hash(this_arg);
32104 return nativeResponseValue;
32106 // MUST_USE_RES struct LDKSha256 RawInvoice_payment_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32108 export function RawInvoice_payment_hash(this_arg: number): number {
32109 if(!isWasmInitialized) {
32110 throw new Error("initializeWasm() must be awaited first!");
32112 const nativeResponseValue = wasm.TS_RawInvoice_payment_hash(this_arg);
32113 return nativeResponseValue;
32115 // MUST_USE_RES struct LDKDescription RawInvoice_description(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32117 export function RawInvoice_description(this_arg: number): number {
32118 if(!isWasmInitialized) {
32119 throw new Error("initializeWasm() must be awaited first!");
32121 const nativeResponseValue = wasm.TS_RawInvoice_description(this_arg);
32122 return nativeResponseValue;
32124 // MUST_USE_RES struct LDKPayeePubKey RawInvoice_payee_pub_key(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32126 export function RawInvoice_payee_pub_key(this_arg: number): number {
32127 if(!isWasmInitialized) {
32128 throw new Error("initializeWasm() must be awaited first!");
32130 const nativeResponseValue = wasm.TS_RawInvoice_payee_pub_key(this_arg);
32131 return nativeResponseValue;
32133 // MUST_USE_RES struct LDKSha256 RawInvoice_description_hash(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32135 export function RawInvoice_description_hash(this_arg: number): number {
32136 if(!isWasmInitialized) {
32137 throw new Error("initializeWasm() must be awaited first!");
32139 const nativeResponseValue = wasm.TS_RawInvoice_description_hash(this_arg);
32140 return nativeResponseValue;
32142 // MUST_USE_RES struct LDKExpiryTime RawInvoice_expiry_time(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32144 export function RawInvoice_expiry_time(this_arg: number): number {
32145 if(!isWasmInitialized) {
32146 throw new Error("initializeWasm() must be awaited first!");
32148 const nativeResponseValue = wasm.TS_RawInvoice_expiry_time(this_arg);
32149 return nativeResponseValue;
32151 // MUST_USE_RES struct LDKMinFinalCltvExpiry RawInvoice_min_final_cltv_expiry(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32153 export function RawInvoice_min_final_cltv_expiry(this_arg: number): number {
32154 if(!isWasmInitialized) {
32155 throw new Error("initializeWasm() must be awaited first!");
32157 const nativeResponseValue = wasm.TS_RawInvoice_min_final_cltv_expiry(this_arg);
32158 return nativeResponseValue;
32160 // MUST_USE_RES struct LDKThirtyTwoBytes RawInvoice_payment_secret(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32162 export function RawInvoice_payment_secret(this_arg: number): number {
32163 if(!isWasmInitialized) {
32164 throw new Error("initializeWasm() must be awaited first!");
32166 const nativeResponseValue = wasm.TS_RawInvoice_payment_secret(this_arg);
32167 return nativeResponseValue;
32169 // MUST_USE_RES struct LDKInvoiceFeatures RawInvoice_features(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32171 export function RawInvoice_features(this_arg: number): number {
32172 if(!isWasmInitialized) {
32173 throw new Error("initializeWasm() must be awaited first!");
32175 const nativeResponseValue = wasm.TS_RawInvoice_features(this_arg);
32176 return nativeResponseValue;
32178 // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawInvoice_private_routes(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32180 export function RawInvoice_private_routes(this_arg: number): number {
32181 if(!isWasmInitialized) {
32182 throw new Error("initializeWasm() must be awaited first!");
32184 const nativeResponseValue = wasm.TS_RawInvoice_private_routes(this_arg);
32185 return nativeResponseValue;
32187 // MUST_USE_RES struct LDKCOption_u64Z RawInvoice_amount_pico_btc(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32189 export function RawInvoice_amount_pico_btc(this_arg: number): number {
32190 if(!isWasmInitialized) {
32191 throw new Error("initializeWasm() must be awaited first!");
32193 const nativeResponseValue = wasm.TS_RawInvoice_amount_pico_btc(this_arg);
32194 return nativeResponseValue;
32196 // MUST_USE_RES enum LDKCurrency RawInvoice_currency(const struct LDKRawInvoice *NONNULL_PTR this_arg);
32198 export function RawInvoice_currency(this_arg: number): Currency {
32199 if(!isWasmInitialized) {
32200 throw new Error("initializeWasm() must be awaited first!");
32202 const nativeResponseValue = wasm.TS_RawInvoice_currency(this_arg);
32203 return nativeResponseValue;
32205 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
32207 export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): number {
32208 if(!isWasmInitialized) {
32209 throw new Error("initializeWasm() must be awaited first!");
32211 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
32212 return nativeResponseValue;
32214 // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
32216 export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): number {
32217 if(!isWasmInitialized) {
32218 throw new Error("initializeWasm() must be awaited first!");
32220 const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
32221 return nativeResponseValue;
32223 // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
32225 export function PositiveTimestamp_as_unix_timestamp(this_arg: number): bigint {
32226 if(!isWasmInitialized) {
32227 throw new Error("initializeWasm() must be awaited first!");
32229 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
32230 return nativeResponseValue;
32232 // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
32234 export function PositiveTimestamp_as_duration_since_epoch(this_arg: number): bigint {
32235 if(!isWasmInitialized) {
32236 throw new Error("initializeWasm() must be awaited first!");
32238 const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
32239 return nativeResponseValue;
32241 // MUST_USE_RES struct LDKSignedRawInvoice Invoice_into_signed_raw(struct LDKInvoice this_arg);
32243 export function Invoice_into_signed_raw(this_arg: number): number {
32244 if(!isWasmInitialized) {
32245 throw new Error("initializeWasm() must be awaited first!");
32247 const nativeResponseValue = wasm.TS_Invoice_into_signed_raw(this_arg);
32248 return nativeResponseValue;
32250 // MUST_USE_RES struct LDKCResult_NoneSemanticErrorZ Invoice_check_signature(const struct LDKInvoice *NONNULL_PTR this_arg);
32252 export function Invoice_check_signature(this_arg: number): number {
32253 if(!isWasmInitialized) {
32254 throw new Error("initializeWasm() must be awaited first!");
32256 const nativeResponseValue = wasm.TS_Invoice_check_signature(this_arg);
32257 return nativeResponseValue;
32259 // MUST_USE_RES struct LDKCResult_InvoiceSemanticErrorZ Invoice_from_signed(struct LDKSignedRawInvoice signed_invoice);
32261 export function Invoice_from_signed(signed_invoice: number): number {
32262 if(!isWasmInitialized) {
32263 throw new Error("initializeWasm() must be awaited first!");
32265 const nativeResponseValue = wasm.TS_Invoice_from_signed(signed_invoice);
32266 return nativeResponseValue;
32268 // MUST_USE_RES uint64_t Invoice_duration_since_epoch(const struct LDKInvoice *NONNULL_PTR this_arg);
32270 export function Invoice_duration_since_epoch(this_arg: number): bigint {
32271 if(!isWasmInitialized) {
32272 throw new Error("initializeWasm() must be awaited first!");
32274 const nativeResponseValue = wasm.TS_Invoice_duration_since_epoch(this_arg);
32275 return nativeResponseValue;
32277 // MUST_USE_RES const uint8_t (*Invoice_payment_hash(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
32279 export function Invoice_payment_hash(this_arg: number): number {
32280 if(!isWasmInitialized) {
32281 throw new Error("initializeWasm() must be awaited first!");
32283 const nativeResponseValue = wasm.TS_Invoice_payment_hash(this_arg);
32284 return nativeResponseValue;
32286 // MUST_USE_RES struct LDKPublicKey Invoice_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
32288 export function Invoice_payee_pub_key(this_arg: number): number {
32289 if(!isWasmInitialized) {
32290 throw new Error("initializeWasm() must be awaited first!");
32292 const nativeResponseValue = wasm.TS_Invoice_payee_pub_key(this_arg);
32293 return nativeResponseValue;
32295 // MUST_USE_RES const uint8_t (*Invoice_payment_secret(const struct LDKInvoice *NONNULL_PTR this_arg))[32];
32297 export function Invoice_payment_secret(this_arg: number): number {
32298 if(!isWasmInitialized) {
32299 throw new Error("initializeWasm() must be awaited first!");
32301 const nativeResponseValue = wasm.TS_Invoice_payment_secret(this_arg);
32302 return nativeResponseValue;
32304 // MUST_USE_RES struct LDKInvoiceFeatures Invoice_features(const struct LDKInvoice *NONNULL_PTR this_arg);
32306 export function Invoice_features(this_arg: number): number {
32307 if(!isWasmInitialized) {
32308 throw new Error("initializeWasm() must be awaited first!");
32310 const nativeResponseValue = wasm.TS_Invoice_features(this_arg);
32311 return nativeResponseValue;
32313 // MUST_USE_RES struct LDKPublicKey Invoice_recover_payee_pub_key(const struct LDKInvoice *NONNULL_PTR this_arg);
32315 export function Invoice_recover_payee_pub_key(this_arg: number): number {
32316 if(!isWasmInitialized) {
32317 throw new Error("initializeWasm() must be awaited first!");
32319 const nativeResponseValue = wasm.TS_Invoice_recover_payee_pub_key(this_arg);
32320 return nativeResponseValue;
32322 // MUST_USE_RES uint64_t Invoice_expiry_time(const struct LDKInvoice *NONNULL_PTR this_arg);
32324 export function Invoice_expiry_time(this_arg: number): bigint {
32325 if(!isWasmInitialized) {
32326 throw new Error("initializeWasm() must be awaited first!");
32328 const nativeResponseValue = wasm.TS_Invoice_expiry_time(this_arg);
32329 return nativeResponseValue;
32331 // MUST_USE_RES bool Invoice_would_expire(const struct LDKInvoice *NONNULL_PTR this_arg, uint64_t at_time);
32333 export function Invoice_would_expire(this_arg: number, at_time: bigint): boolean {
32334 if(!isWasmInitialized) {
32335 throw new Error("initializeWasm() must be awaited first!");
32337 const nativeResponseValue = wasm.TS_Invoice_would_expire(this_arg, at_time);
32338 return nativeResponseValue;
32340 // MUST_USE_RES uint64_t Invoice_min_final_cltv_expiry(const struct LDKInvoice *NONNULL_PTR this_arg);
32342 export function Invoice_min_final_cltv_expiry(this_arg: number): bigint {
32343 if(!isWasmInitialized) {
32344 throw new Error("initializeWasm() must be awaited first!");
32346 const nativeResponseValue = wasm.TS_Invoice_min_final_cltv_expiry(this_arg);
32347 return nativeResponseValue;
32349 // MUST_USE_RES struct LDKCVec_PrivateRouteZ Invoice_private_routes(const struct LDKInvoice *NONNULL_PTR this_arg);
32351 export function Invoice_private_routes(this_arg: number): number {
32352 if(!isWasmInitialized) {
32353 throw new Error("initializeWasm() must be awaited first!");
32355 const nativeResponseValue = wasm.TS_Invoice_private_routes(this_arg);
32356 return nativeResponseValue;
32358 // MUST_USE_RES struct LDKCVec_RouteHintZ Invoice_route_hints(const struct LDKInvoice *NONNULL_PTR this_arg);
32360 export function Invoice_route_hints(this_arg: number): number {
32361 if(!isWasmInitialized) {
32362 throw new Error("initializeWasm() must be awaited first!");
32364 const nativeResponseValue = wasm.TS_Invoice_route_hints(this_arg);
32365 return nativeResponseValue;
32367 // MUST_USE_RES enum LDKCurrency Invoice_currency(const struct LDKInvoice *NONNULL_PTR this_arg);
32369 export function Invoice_currency(this_arg: number): Currency {
32370 if(!isWasmInitialized) {
32371 throw new Error("initializeWasm() must be awaited first!");
32373 const nativeResponseValue = wasm.TS_Invoice_currency(this_arg);
32374 return nativeResponseValue;
32376 // MUST_USE_RES struct LDKCOption_u64Z Invoice_amount_milli_satoshis(const struct LDKInvoice *NONNULL_PTR this_arg);
32378 export function Invoice_amount_milli_satoshis(this_arg: number): number {
32379 if(!isWasmInitialized) {
32380 throw new Error("initializeWasm() must be awaited first!");
32382 const nativeResponseValue = wasm.TS_Invoice_amount_milli_satoshis(this_arg);
32383 return nativeResponseValue;
32385 // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
32387 export function Description_new(description: number): number {
32388 if(!isWasmInitialized) {
32389 throw new Error("initializeWasm() must be awaited first!");
32391 const nativeResponseValue = wasm.TS_Description_new(description);
32392 return nativeResponseValue;
32394 // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
32396 export function Description_into_inner(this_arg: number): number {
32397 if(!isWasmInitialized) {
32398 throw new Error("initializeWasm() must be awaited first!");
32400 const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
32401 return nativeResponseValue;
32403 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
32405 export function ExpiryTime_from_seconds(seconds: bigint): number {
32406 if(!isWasmInitialized) {
32407 throw new Error("initializeWasm() must be awaited first!");
32409 const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
32410 return nativeResponseValue;
32412 // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
32414 export function ExpiryTime_from_duration(duration: bigint): number {
32415 if(!isWasmInitialized) {
32416 throw new Error("initializeWasm() must be awaited first!");
32418 const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
32419 return nativeResponseValue;
32421 // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
32423 export function ExpiryTime_as_seconds(this_arg: number): bigint {
32424 if(!isWasmInitialized) {
32425 throw new Error("initializeWasm() must be awaited first!");
32427 const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
32428 return nativeResponseValue;
32430 // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
32432 export function ExpiryTime_as_duration(this_arg: number): bigint {
32433 if(!isWasmInitialized) {
32434 throw new Error("initializeWasm() must be awaited first!");
32436 const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
32437 return nativeResponseValue;
32439 // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
32441 export function PrivateRoute_new(hops: number): number {
32442 if(!isWasmInitialized) {
32443 throw new Error("initializeWasm() must be awaited first!");
32445 const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
32446 return nativeResponseValue;
32448 // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
32450 export function PrivateRoute_into_inner(this_arg: number): number {
32451 if(!isWasmInitialized) {
32452 throw new Error("initializeWasm() must be awaited first!");
32454 const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
32455 return nativeResponseValue;
32457 // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
32459 export function CreationError_clone(orig: number): CreationError {
32460 if(!isWasmInitialized) {
32461 throw new Error("initializeWasm() must be awaited first!");
32463 const nativeResponseValue = wasm.TS_CreationError_clone(orig);
32464 return nativeResponseValue;
32466 // enum LDKCreationError CreationError_description_too_long(void);
32468 export function CreationError_description_too_long(): CreationError {
32469 if(!isWasmInitialized) {
32470 throw new Error("initializeWasm() must be awaited first!");
32472 const nativeResponseValue = wasm.TS_CreationError_description_too_long();
32473 return nativeResponseValue;
32475 // enum LDKCreationError CreationError_route_too_long(void);
32477 export function CreationError_route_too_long(): CreationError {
32478 if(!isWasmInitialized) {
32479 throw new Error("initializeWasm() must be awaited first!");
32481 const nativeResponseValue = wasm.TS_CreationError_route_too_long();
32482 return nativeResponseValue;
32484 // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
32486 export function CreationError_timestamp_out_of_bounds(): CreationError {
32487 if(!isWasmInitialized) {
32488 throw new Error("initializeWasm() must be awaited first!");
32490 const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
32491 return nativeResponseValue;
32493 // enum LDKCreationError CreationError_invalid_amount(void);
32495 export function CreationError_invalid_amount(): CreationError {
32496 if(!isWasmInitialized) {
32497 throw new Error("initializeWasm() must be awaited first!");
32499 const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
32500 return nativeResponseValue;
32502 // enum LDKCreationError CreationError_missing_route_hints(void);
32504 export function CreationError_missing_route_hints(): CreationError {
32505 if(!isWasmInitialized) {
32506 throw new Error("initializeWasm() must be awaited first!");
32508 const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
32509 return nativeResponseValue;
32511 // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
32513 export function CreationError_eq(a: number, b: number): boolean {
32514 if(!isWasmInitialized) {
32515 throw new Error("initializeWasm() must be awaited first!");
32517 const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
32518 return nativeResponseValue;
32520 // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
32522 export function CreationError_to_str(o: number): number {
32523 if(!isWasmInitialized) {
32524 throw new Error("initializeWasm() must be awaited first!");
32526 const nativeResponseValue = wasm.TS_CreationError_to_str(o);
32527 return nativeResponseValue;
32529 // enum LDKSemanticError SemanticError_clone(const enum LDKSemanticError *NONNULL_PTR orig);
32531 export function SemanticError_clone(orig: number): SemanticError {
32532 if(!isWasmInitialized) {
32533 throw new Error("initializeWasm() must be awaited first!");
32535 const nativeResponseValue = wasm.TS_SemanticError_clone(orig);
32536 return nativeResponseValue;
32538 // enum LDKSemanticError SemanticError_no_payment_hash(void);
32540 export function SemanticError_no_payment_hash(): SemanticError {
32541 if(!isWasmInitialized) {
32542 throw new Error("initializeWasm() must be awaited first!");
32544 const nativeResponseValue = wasm.TS_SemanticError_no_payment_hash();
32545 return nativeResponseValue;
32547 // enum LDKSemanticError SemanticError_multiple_payment_hashes(void);
32549 export function SemanticError_multiple_payment_hashes(): SemanticError {
32550 if(!isWasmInitialized) {
32551 throw new Error("initializeWasm() must be awaited first!");
32553 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_hashes();
32554 return nativeResponseValue;
32556 // enum LDKSemanticError SemanticError_no_description(void);
32558 export function SemanticError_no_description(): SemanticError {
32559 if(!isWasmInitialized) {
32560 throw new Error("initializeWasm() must be awaited first!");
32562 const nativeResponseValue = wasm.TS_SemanticError_no_description();
32563 return nativeResponseValue;
32565 // enum LDKSemanticError SemanticError_multiple_descriptions(void);
32567 export function SemanticError_multiple_descriptions(): SemanticError {
32568 if(!isWasmInitialized) {
32569 throw new Error("initializeWasm() must be awaited first!");
32571 const nativeResponseValue = wasm.TS_SemanticError_multiple_descriptions();
32572 return nativeResponseValue;
32574 // enum LDKSemanticError SemanticError_no_payment_secret(void);
32576 export function SemanticError_no_payment_secret(): SemanticError {
32577 if(!isWasmInitialized) {
32578 throw new Error("initializeWasm() must be awaited first!");
32580 const nativeResponseValue = wasm.TS_SemanticError_no_payment_secret();
32581 return nativeResponseValue;
32583 // enum LDKSemanticError SemanticError_multiple_payment_secrets(void);
32585 export function SemanticError_multiple_payment_secrets(): SemanticError {
32586 if(!isWasmInitialized) {
32587 throw new Error("initializeWasm() must be awaited first!");
32589 const nativeResponseValue = wasm.TS_SemanticError_multiple_payment_secrets();
32590 return nativeResponseValue;
32592 // enum LDKSemanticError SemanticError_invalid_features(void);
32594 export function SemanticError_invalid_features(): SemanticError {
32595 if(!isWasmInitialized) {
32596 throw new Error("initializeWasm() must be awaited first!");
32598 const nativeResponseValue = wasm.TS_SemanticError_invalid_features();
32599 return nativeResponseValue;
32601 // enum LDKSemanticError SemanticError_invalid_recovery_id(void);
32603 export function SemanticError_invalid_recovery_id(): SemanticError {
32604 if(!isWasmInitialized) {
32605 throw new Error("initializeWasm() must be awaited first!");
32607 const nativeResponseValue = wasm.TS_SemanticError_invalid_recovery_id();
32608 return nativeResponseValue;
32610 // enum LDKSemanticError SemanticError_invalid_signature(void);
32612 export function SemanticError_invalid_signature(): SemanticError {
32613 if(!isWasmInitialized) {
32614 throw new Error("initializeWasm() must be awaited first!");
32616 const nativeResponseValue = wasm.TS_SemanticError_invalid_signature();
32617 return nativeResponseValue;
32619 // enum LDKSemanticError SemanticError_imprecise_amount(void);
32621 export function SemanticError_imprecise_amount(): SemanticError {
32622 if(!isWasmInitialized) {
32623 throw new Error("initializeWasm() must be awaited first!");
32625 const nativeResponseValue = wasm.TS_SemanticError_imprecise_amount();
32626 return nativeResponseValue;
32628 // bool SemanticError_eq(const enum LDKSemanticError *NONNULL_PTR a, const enum LDKSemanticError *NONNULL_PTR b);
32630 export function SemanticError_eq(a: number, b: number): boolean {
32631 if(!isWasmInitialized) {
32632 throw new Error("initializeWasm() must be awaited first!");
32634 const nativeResponseValue = wasm.TS_SemanticError_eq(a, b);
32635 return nativeResponseValue;
32637 // struct LDKStr SemanticError_to_str(const enum LDKSemanticError *NONNULL_PTR o);
32639 export function SemanticError_to_str(o: number): number {
32640 if(!isWasmInitialized) {
32641 throw new Error("initializeWasm() must be awaited first!");
32643 const nativeResponseValue = wasm.TS_SemanticError_to_str(o);
32644 return nativeResponseValue;
32646 // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
32648 export function SignOrCreationError_free(this_ptr: number): void {
32649 if(!isWasmInitialized) {
32650 throw new Error("initializeWasm() must be awaited first!");
32652 const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
32653 // debug statements here
32655 // uintptr_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
32657 export function SignOrCreationError_clone_ptr(arg: number): number {
32658 if(!isWasmInitialized) {
32659 throw new Error("initializeWasm() must be awaited first!");
32661 const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
32662 return nativeResponseValue;
32664 // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
32666 export function SignOrCreationError_clone(orig: number): number {
32667 if(!isWasmInitialized) {
32668 throw new Error("initializeWasm() must be awaited first!");
32670 const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
32671 return nativeResponseValue;
32673 // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
32675 export function SignOrCreationError_sign_error(): number {
32676 if(!isWasmInitialized) {
32677 throw new Error("initializeWasm() must be awaited first!");
32679 const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
32680 return nativeResponseValue;
32682 // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
32684 export function SignOrCreationError_creation_error(a: CreationError): number {
32685 if(!isWasmInitialized) {
32686 throw new Error("initializeWasm() must be awaited first!");
32688 const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
32689 return nativeResponseValue;
32691 // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
32693 export function SignOrCreationError_eq(a: number, b: number): boolean {
32694 if(!isWasmInitialized) {
32695 throw new Error("initializeWasm() must be awaited first!");
32697 const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
32698 return nativeResponseValue;
32700 // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
32702 export function SignOrCreationError_to_str(o: number): number {
32703 if(!isWasmInitialized) {
32704 throw new Error("initializeWasm() must be awaited first!");
32706 const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
32707 return nativeResponseValue;
32709 // void InvoicePayer_free(struct LDKInvoicePayer this_obj);
32711 export function InvoicePayer_free(this_obj: number): void {
32712 if(!isWasmInitialized) {
32713 throw new Error("initializeWasm() must be awaited first!");
32715 const nativeResponseValue = wasm.TS_InvoicePayer_free(this_obj);
32716 // debug statements here
32718 // void Payer_free(struct LDKPayer this_ptr);
32720 export function Payer_free(this_ptr: number): void {
32721 if(!isWasmInitialized) {
32722 throw new Error("initializeWasm() must be awaited first!");
32724 const nativeResponseValue = wasm.TS_Payer_free(this_ptr);
32725 // debug statements here
32727 // void Router_free(struct LDKRouter this_ptr);
32729 export function Router_free(this_ptr: number): void {
32730 if(!isWasmInitialized) {
32731 throw new Error("initializeWasm() must be awaited first!");
32733 const nativeResponseValue = wasm.TS_Router_free(this_ptr);
32734 // debug statements here
32736 // void Retry_free(struct LDKRetry this_ptr);
32738 export function Retry_free(this_ptr: number): void {
32739 if(!isWasmInitialized) {
32740 throw new Error("initializeWasm() must be awaited first!");
32742 const nativeResponseValue = wasm.TS_Retry_free(this_ptr);
32743 // debug statements here
32745 // uintptr_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg);
32747 export function Retry_clone_ptr(arg: number): number {
32748 if(!isWasmInitialized) {
32749 throw new Error("initializeWasm() must be awaited first!");
32751 const nativeResponseValue = wasm.TS_Retry_clone_ptr(arg);
32752 return nativeResponseValue;
32754 // struct LDKRetry Retry_clone(const struct LDKRetry *NONNULL_PTR orig);
32756 export function Retry_clone(orig: number): number {
32757 if(!isWasmInitialized) {
32758 throw new Error("initializeWasm() must be awaited first!");
32760 const nativeResponseValue = wasm.TS_Retry_clone(orig);
32761 return nativeResponseValue;
32763 // struct LDKRetry Retry_attempts(uintptr_t a);
32765 export function Retry_attempts(a: number): number {
32766 if(!isWasmInitialized) {
32767 throw new Error("initializeWasm() must be awaited first!");
32769 const nativeResponseValue = wasm.TS_Retry_attempts(a);
32770 return nativeResponseValue;
32772 // bool Retry_eq(const struct LDKRetry *NONNULL_PTR a, const struct LDKRetry *NONNULL_PTR b);
32774 export function Retry_eq(a: number, b: number): boolean {
32775 if(!isWasmInitialized) {
32776 throw new Error("initializeWasm() must be awaited first!");
32778 const nativeResponseValue = wasm.TS_Retry_eq(a, b);
32779 return nativeResponseValue;
32781 // uint64_t Retry_hash(const struct LDKRetry *NONNULL_PTR o);
32783 export function Retry_hash(o: number): bigint {
32784 if(!isWasmInitialized) {
32785 throw new Error("initializeWasm() must be awaited first!");
32787 const nativeResponseValue = wasm.TS_Retry_hash(o);
32788 return nativeResponseValue;
32790 // void PaymentError_free(struct LDKPaymentError this_ptr);
32792 export function PaymentError_free(this_ptr: number): void {
32793 if(!isWasmInitialized) {
32794 throw new Error("initializeWasm() must be awaited first!");
32796 const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
32797 // debug statements here
32799 // uintptr_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
32801 export function PaymentError_clone_ptr(arg: number): number {
32802 if(!isWasmInitialized) {
32803 throw new Error("initializeWasm() must be awaited first!");
32805 const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
32806 return nativeResponseValue;
32808 // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
32810 export function PaymentError_clone(orig: number): number {
32811 if(!isWasmInitialized) {
32812 throw new Error("initializeWasm() must be awaited first!");
32814 const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
32815 return nativeResponseValue;
32817 // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
32819 export function PaymentError_invoice(a: number): number {
32820 if(!isWasmInitialized) {
32821 throw new Error("initializeWasm() must be awaited first!");
32823 const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
32824 return nativeResponseValue;
32826 // struct LDKPaymentError PaymentError_routing(struct LDKLightningError a);
32828 export function PaymentError_routing(a: number): number {
32829 if(!isWasmInitialized) {
32830 throw new Error("initializeWasm() must be awaited first!");
32832 const nativeResponseValue = wasm.TS_PaymentError_routing(a);
32833 return nativeResponseValue;
32835 // struct LDKPaymentError PaymentError_sending(struct LDKPaymentSendFailure a);
32837 export function PaymentError_sending(a: number): number {
32838 if(!isWasmInitialized) {
32839 throw new Error("initializeWasm() must be awaited first!");
32841 const nativeResponseValue = wasm.TS_PaymentError_sending(a);
32842 return nativeResponseValue;
32844 // 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);
32846 export function InvoicePayer_new(payer: number, router: number, scorer: number, logger: number, event_handler: number, retry: number): number {
32847 if(!isWasmInitialized) {
32848 throw new Error("initializeWasm() must be awaited first!");
32850 const nativeResponseValue = wasm.TS_InvoicePayer_new(payer, router, scorer, logger, event_handler, retry);
32851 return nativeResponseValue;
32853 // MUST_USE_RES struct LDKCResult_PaymentIdPaymentErrorZ InvoicePayer_pay_invoice(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const struct LDKInvoice *NONNULL_PTR invoice);
32855 export function InvoicePayer_pay_invoice(this_arg: number, invoice: number): number {
32856 if(!isWasmInitialized) {
32857 throw new Error("initializeWasm() must be awaited first!");
32859 const nativeResponseValue = wasm.TS_InvoicePayer_pay_invoice(this_arg, invoice);
32860 return nativeResponseValue;
32862 // 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);
32864 export function InvoicePayer_pay_zero_value_invoice(this_arg: number, invoice: number, amount_msats: bigint): number {
32865 if(!isWasmInitialized) {
32866 throw new Error("initializeWasm() must be awaited first!");
32868 const nativeResponseValue = wasm.TS_InvoicePayer_pay_zero_value_invoice(this_arg, invoice, amount_msats);
32869 return nativeResponseValue;
32871 // 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);
32873 export function InvoicePayer_pay_pubkey(this_arg: number, pubkey: number, payment_preimage: number, amount_msats: bigint, final_cltv_expiry_delta: number): number {
32874 if(!isWasmInitialized) {
32875 throw new Error("initializeWasm() must be awaited first!");
32877 const nativeResponseValue = wasm.TS_InvoicePayer_pay_pubkey(this_arg, pubkey, payment_preimage, amount_msats, final_cltv_expiry_delta);
32878 return nativeResponseValue;
32880 // void InvoicePayer_remove_cached_payment(const struct LDKInvoicePayer *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32]);
32882 export function InvoicePayer_remove_cached_payment(this_arg: number, payment_hash: number): void {
32883 if(!isWasmInitialized) {
32884 throw new Error("initializeWasm() must be awaited first!");
32886 const nativeResponseValue = wasm.TS_InvoicePayer_remove_cached_payment(this_arg, payment_hash);
32887 // debug statements here
32889 // struct LDKEventHandler InvoicePayer_as_EventHandler(const struct LDKInvoicePayer *NONNULL_PTR this_arg);
32891 export function InvoicePayer_as_EventHandler(this_arg: number): number {
32892 if(!isWasmInitialized) {
32893 throw new Error("initializeWasm() must be awaited first!");
32895 const nativeResponseValue = wasm.TS_InvoicePayer_as_EventHandler(this_arg);
32896 return nativeResponseValue;
32898 // 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);
32900 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 {
32901 if(!isWasmInitialized) {
32902 throw new Error("initializeWasm() must be awaited first!");
32904 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);
32905 return nativeResponseValue;
32907 // 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);
32909 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 {
32910 if(!isWasmInitialized) {
32911 throw new Error("initializeWasm() must be awaited first!");
32913 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);
32914 return nativeResponseValue;
32916 // void DefaultRouter_free(struct LDKDefaultRouter this_obj);
32918 export function DefaultRouter_free(this_obj: number): void {
32919 if(!isWasmInitialized) {
32920 throw new Error("initializeWasm() must be awaited first!");
32922 const nativeResponseValue = wasm.TS_DefaultRouter_free(this_obj);
32923 // debug statements here
32925 // MUST_USE_RES struct LDKDefaultRouter DefaultRouter_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger, struct LDKThirtyTwoBytes random_seed_bytes);
32927 export function DefaultRouter_new(network_graph: number, logger: number, random_seed_bytes: number): number {
32928 if(!isWasmInitialized) {
32929 throw new Error("initializeWasm() must be awaited first!");
32931 const nativeResponseValue = wasm.TS_DefaultRouter_new(network_graph, logger, random_seed_bytes);
32932 return nativeResponseValue;
32934 // struct LDKRouter DefaultRouter_as_Router(const struct LDKDefaultRouter *NONNULL_PTR this_arg);
32936 export function DefaultRouter_as_Router(this_arg: number): number {
32937 if(!isWasmInitialized) {
32938 throw new Error("initializeWasm() must be awaited first!");
32940 const nativeResponseValue = wasm.TS_DefaultRouter_as_Router(this_arg);
32941 return nativeResponseValue;
32943 // struct LDKPayer ChannelManager_as_Payer(const struct LDKChannelManager *NONNULL_PTR this_arg);
32945 export function ChannelManager_as_Payer(this_arg: number): number {
32946 if(!isWasmInitialized) {
32947 throw new Error("initializeWasm() must be awaited first!");
32949 const nativeResponseValue = wasm.TS_ChannelManager_as_Payer(this_arg);
32950 return nativeResponseValue;
32952 // struct LDKCResult_SiPrefixParseErrorZ SiPrefix_from_str(struct LDKStr s);
32954 export function SiPrefix_from_str(s: number): number {
32955 if(!isWasmInitialized) {
32956 throw new Error("initializeWasm() must be awaited first!");
32958 const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
32959 return nativeResponseValue;
32961 // struct LDKCResult_InvoiceParseOrSemanticErrorZ Invoice_from_str(struct LDKStr s);
32963 export function Invoice_from_str(s: number): number {
32964 if(!isWasmInitialized) {
32965 throw new Error("initializeWasm() must be awaited first!");
32967 const nativeResponseValue = wasm.TS_Invoice_from_str(s);
32968 return nativeResponseValue;
32970 // struct LDKCResult_SignedRawInvoiceParseErrorZ SignedRawInvoice_from_str(struct LDKStr s);
32972 export function SignedRawInvoice_from_str(s: number): number {
32973 if(!isWasmInitialized) {
32974 throw new Error("initializeWasm() must be awaited first!");
32976 const nativeResponseValue = wasm.TS_SignedRawInvoice_from_str(s);
32977 return nativeResponseValue;
32979 // struct LDKStr ParseError_to_str(const struct LDKParseError *NONNULL_PTR o);
32981 export function ParseError_to_str(o: number): number {
32982 if(!isWasmInitialized) {
32983 throw new Error("initializeWasm() must be awaited first!");
32985 const nativeResponseValue = wasm.TS_ParseError_to_str(o);
32986 return nativeResponseValue;
32988 // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
32990 export function ParseOrSemanticError_to_str(o: number): number {
32991 if(!isWasmInitialized) {
32992 throw new Error("initializeWasm() must be awaited first!");
32994 const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
32995 return nativeResponseValue;
32997 // struct LDKStr Invoice_to_str(const struct LDKInvoice *NONNULL_PTR o);
32999 export function Invoice_to_str(o: number): number {
33000 if(!isWasmInitialized) {
33001 throw new Error("initializeWasm() must be awaited first!");
33003 const nativeResponseValue = wasm.TS_Invoice_to_str(o);
33004 return nativeResponseValue;
33006 // struct LDKStr SignedRawInvoice_to_str(const struct LDKSignedRawInvoice *NONNULL_PTR o);
33008 export function SignedRawInvoice_to_str(o: number): number {
33009 if(!isWasmInitialized) {
33010 throw new Error("initializeWasm() must be awaited first!");
33012 const nativeResponseValue = wasm.TS_SignedRawInvoice_to_str(o);
33013 return nativeResponseValue;
33015 // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
33017 export function Currency_to_str(o: number): number {
33018 if(!isWasmInitialized) {
33019 throw new Error("initializeWasm() must be awaited first!");
33021 const nativeResponseValue = wasm.TS_Currency_to_str(o);
33022 return nativeResponseValue;
33024 // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
33026 export function SiPrefix_to_str(o: number): number {
33027 if(!isWasmInitialized) {
33028 throw new Error("initializeWasm() must be awaited first!");
33030 const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
33031 return nativeResponseValue;
33035 js_invoke = function(obj_ptr: number, fn_id: number, arg1: bigint|number, arg2: bigint|number, arg3: bigint|number, arg4: bigint|number, arg5: bigint|number, arg6: bigint|number, arg7: bigint|number, arg8: bigint|number, arg9: bigint|number, arg10: bigint|number) {
33036 const weak: WeakRef<object> = js_objs[obj_ptr];
33037 if (weak == null || weak == undefined) {
33038 console.error("Got function call on unknown/free'd JS object!");
33039 throw new Error("Got function call on unknown/free'd JS object!");
33041 const obj: object = weak.deref();
33042 if (obj == null || obj == undefined) {
33043 console.error("Got function call on GC'd JS object!");
33044 throw new Error("Got function call on GC'd JS object!");
33048 case 0: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
33049 case 1: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
33050 case 2: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
33051 case 3: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
33052 case 4: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
33053 case 5: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
33054 case 6: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
33055 case 7: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
33056 case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
33057 case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
33058 case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
33059 case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
33060 case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
33061 case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement"); break;
33062 case 14: fn = Object.getOwnPropertyDescriptor(obj, "ready_channel"); break;
33063 case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33064 case 16: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
33065 case 17: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
33066 case 18: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
33067 case 19: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transaction"); break;
33068 case 20: fn = Object.getOwnPropertyDescriptor(obj, "get_node_secret"); break;
33069 case 21: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
33070 case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
33071 case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_channel_signer"); break;
33072 case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
33073 case 25: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
33074 case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
33075 case 27: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
33076 case 28: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
33077 case 29: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
33078 case 30: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
33079 case 31: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33080 case 32: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
33081 case 33: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
33082 case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
33083 case 35: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
33084 case 36: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
33085 case 37: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
33086 case 38: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
33087 case 39: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
33088 case 40: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
33089 case 41: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
33090 case 42: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
33091 case 43: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
33092 case 44: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
33093 case 45: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
33094 case 46: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
33095 case 47: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
33096 case 48: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
33097 case 49: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
33098 case 50: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
33099 case 51: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
33100 case 52: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
33101 case 53: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
33102 case 54: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
33103 case 55: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
33104 case 56: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
33105 case 57: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
33106 case 58: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
33107 case 59: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
33108 case 60: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
33109 case 61: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
33110 case 62: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
33111 case 63: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
33112 case 64: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
33113 case 65: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
33114 case 66: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
33115 case 67: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
33116 case 68: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
33117 case 69: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
33118 case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
33119 case 71: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
33120 case 72: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
33121 case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
33122 case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
33123 case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
33124 case 76: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcements"); break;
33125 case 77: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcements"); break;
33126 case 78: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
33127 case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
33128 case 80: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
33129 case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
33130 case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
33131 case 83: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
33132 case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
33133 case 85: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
33134 case 86: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
33135 case 87: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
33136 case 88: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
33137 case 89: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
33138 case 90: fn = Object.getOwnPropertyDescriptor(obj, "lock"); break;
33139 case 91: fn = Object.getOwnPropertyDescriptor(obj, "node_id"); break;
33140 case 92: fn = Object.getOwnPropertyDescriptor(obj, "first_hops"); break;
33141 case 93: fn = Object.getOwnPropertyDescriptor(obj, "send_payment"); break;
33142 case 94: fn = Object.getOwnPropertyDescriptor(obj, "send_spontaneous_payment"); break;
33143 case 95: fn = Object.getOwnPropertyDescriptor(obj, "retry_payment"); break;
33144 case 96: fn = Object.getOwnPropertyDescriptor(obj, "abandon_payment"); break;
33145 case 97: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
33147 console.error("Got unknown function call from C!");
33148 throw new Error("Got unknown function call from C!");
33150 if (fn == null || fn == undefined) {
33151 console.error("Got function call on incorrect JS object!");
33152 throw new Error("Got function call on incorrect JS object!");
33154 const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
33155 if (ret === undefined || ret === null) return BigInt(0);
33156 return BigInt(ret);